Repository: kernitus/BukkitOldCombatMechanics Branch: master Commit: 7edb0a525dc4 Files: 129 Total size: 1.2 MB Directory structure: gitextract_5hk29j6x/ ├── .github/ │ ├── CONTRIBUTING.md │ ├── ISSUE_TEMPLATE/ │ │ ├── 1-bug-report.yaml │ │ ├── 2-question.yaml │ │ ├── 3-feature.yaml │ │ └── config.yml │ ├── release-please-config.json │ ├── release-please-manifest.json │ └── workflows/ │ ├── build-upload-release.yml │ ├── dev-builds.yml │ ├── release-please.yml │ └── wrap-issue-form-codeblocks.yml ├── .gitignore ├── AGENTS.md ├── CHANGELOG.md ├── LICENCE ├── README.md ├── build.gradle.kts ├── gradle.properties ├── gradlew ├── gradlew.bat ├── settings.gradle.kts └── src/ ├── integrationTest/ │ ├── kotlin/ │ │ └── kernitus/ │ │ └── plugin/ │ │ └── OldCombatMechanics/ │ │ ├── AttackCompat.kt │ │ ├── AttackCooldownHeldItemIntegrationTest.kt │ │ ├── AttackCooldownTrackerIntegrationTest.kt │ │ ├── AttackRangeIntegrationTest.kt │ │ ├── AttributeModifierCompat.kt │ │ ├── ChorusFruitIntegrationTest.kt │ │ ├── ConfigMigrationIntegrationTest.kt │ │ ├── ConsumableComponentIntegrationTest.kt │ │ ├── CopperToolsIntegrationTest.kt │ │ ├── CustomWeaponDamageIntegrationTest.kt │ │ ├── DisableOffhandIntegrationTest.kt │ │ ├── DisableOffhandReflectionIntegrationTest.kt │ │ ├── EnderpearlCooldownIntegrationTest.kt │ │ ├── FakePlayer.kt │ │ ├── FireAspectOverdamageIntegrationTest.kt │ │ ├── FishingRodVelocityIntegrationTest.kt │ │ ├── GoldenAppleIntegrationTest.kt │ │ ├── InGameTester.kt │ │ ├── InGameTesterIntegrationTest.kt │ │ ├── InvulnerabilityDamageIntegrationTest.kt │ │ ├── KotestRunner.kt │ │ ├── LegacyFakePlayer12.kt │ │ ├── LegacyFakePlayer9.kt │ │ ├── ModesetRulesIntegrationTest.kt │ │ ├── OCMTest.kt │ │ ├── OCMTestMain.kt │ │ ├── OldArmourDurabilityIntegrationTest.kt │ │ ├── OldCriticalHitsIntegrationTest.kt │ │ ├── OldPotionEffectsIntegrationTest.kt │ │ ├── OldToolDamageMobIntegrationTest.kt │ │ ├── PacketCancellationIntegrationTest.kt │ │ ├── PaperSwordBlockingDamageReductionIntegrationTest.kt │ │ ├── PlayerKnockbackIntegrationTest.kt │ │ ├── PlayerRegenIntegrationTest.kt │ │ ├── SpigotFunctionChooserIntegrationTest.kt │ │ ├── SwordBlockingIntegrationTest.kt │ │ ├── SwordSweepIntegrationTest.kt │ │ ├── Tally.kt │ │ ├── TestResultWriter.kt │ │ ├── TesterUtils.kt │ │ ├── ToolDamageTooltipIntegrationTest.kt │ │ └── WeaponDurabilityIntegrationTest.kt │ └── resources/ │ └── plugin.yml └── main/ ├── java/ │ └── kernitus/ │ └── plugin/ │ └── OldCombatMechanics/ │ ├── ModuleLoader.java │ ├── OCMConfigHandler.java │ ├── OCMMain.java │ ├── UpdateChecker.java │ ├── commands/ │ │ ├── OCMCommandCompleter.java │ │ └── OCMCommandHandler.java │ ├── hooks/ │ │ ├── PlaceholderAPIHook.java │ │ └── api/ │ │ └── Hook.java │ ├── module/ │ │ ├── ModuleAttackCooldown.java │ │ ├── ModuleAttackFrequency.java │ │ ├── ModuleAttackRange.java │ │ ├── ModuleAttackSounds.java │ │ ├── ModuleChorusFruit.java │ │ ├── ModuleDisableCrafting.java │ │ ├── ModuleDisableEnderpearlCooldown.java │ │ ├── ModuleDisableOffHand.java │ │ ├── ModuleFishingKnockback.java │ │ ├── ModuleFishingRodVelocity.java │ │ ├── ModuleGoldenApple.java │ │ ├── ModuleOldArmourDurability.java │ │ ├── ModuleOldArmourStrength.java │ │ ├── ModuleOldBrewingStand.java │ │ ├── ModuleOldBurnDelay.java │ │ ├── ModuleOldCriticalHits.java │ │ ├── ModuleOldPotionEffects.java │ │ ├── ModuleOldToolDamage.java │ │ ├── ModulePlayerKnockback.java │ │ ├── ModulePlayerRegen.java │ │ ├── ModuleProjectileKnockback.java │ │ ├── ModuleShieldDamageReduction.java │ │ ├── ModuleSwordBlocking.java │ │ ├── ModuleSwordSweep.java │ │ ├── ModuleSwordSweepParticles.java │ │ └── OCMModule.java │ ├── paper/ │ │ └── PaperSwordBlocking.java │ ├── updater/ │ │ ├── ModuleUpdateChecker.java │ │ ├── SpigetUpdateChecker.java │ │ └── VersionChecker.java │ └── utilities/ │ ├── Config.java │ ├── ConfigUtils.java │ ├── EventRegistry.java │ ├── MathsHelper.java │ ├── Messenger.java │ ├── TextUtils.java │ ├── damage/ │ │ ├── AttackCooldownTracker.java │ │ ├── DamageUtils.java │ │ ├── DefenceUtils.java │ │ ├── EntityDamageByEntityListener.java │ │ ├── MobDamage.java │ │ ├── NewWeaponDamage.java │ │ ├── OCMEntityDamageByEntityEvent.java │ │ └── WeaponDamages.java │ ├── potions/ │ │ ├── PotionDurations.java │ │ ├── PotionEffects.java │ │ ├── PotionKey.java │ │ └── WeaknessCompensation.java │ ├── reflection/ │ │ ├── Reflector.java │ │ ├── SpigotFunctionChooser.java │ │ └── VersionCompatUtils.java │ └── storage/ │ ├── ModesetListener.java │ ├── PlayerData.java │ ├── PlayerDataCodec.java │ └── PlayerStorage.java └── resources/ ├── config.yml └── plugin.yml ================================================ FILE CONTENTS ================================================ ================================================ FILE: .github/CONTRIBUTING.md ================================================ # Contributing All contributions should be in the form of [pull requests](https://github.com/kernitus/BukkitOldCombatMechanics/pulls), and should use the formatting profiles provided at the bottom of this page. All pull requests must be fully functional and able to compile, and should be fully tested. Please submit **monofocal** pull requests, i.e.if you're making unrelated changes to two different modules, or decide to also update the version of a dependency, *those should be separate pull requests*. ## Testing expectations Contributions are expected to include automated test coverage within the existing test framework where practical. For behaviour changes, bug fixes, and new features, prefer adding or updating tests in the existing Kotlin integration-test harness rather than relying on manual testing alone. ## Language expectations New classes should be written in Kotlin by default. If you are modifying an existing Java class, keep the surrounding file consistent unless there is a clear reason to migrate it as part of the same change. ## Module system OldCombatMechanics uses a modular system to make sure each feature is completely independent from any other, and can be toggled off and have no impact on server performance. This means each new module must extend the `Module` class, and implement a public constructor which takes an instance of the plugin and passes the module name to the superconstructor. The `Module` class also provides an overloadable `reload()` method which is called whenever the plugin is reloaded. If you are using any class-level variables they should probably be updated in here. This should also be used for any initialisation that might need to be done if the config section is changed and `ocm reload` is called. You may then call `reload()` from the constructor. ## Module naming The name specified in the module constructor must be the same as the one used in the config.yml. The module name must meaningfully describe the purpose of the module, for example `disable-offhand` or `old-burn-delay`. The module classes should thus be respectively named `ModuleDisableOffhand` and `ModuleOldBurnDelay`. As you can see, kebab case is used for the constructor and config name, while pascal case prefixed by `Module` is used for class names. ## Module configuration All module configuration is done through the Module class in a subsection of the config.yml for each module. To access config variables under the module section, you can use the methods provided by `module()`, such as `module().getBoolean("enableBlue")`. The module config section must contain an `enabled` boolean key which is used by the module system to selectively register/unregister the module, and, if applicable, a `worlds: []` list key to configure which worlds your module will work in. It is the responsibility of the module to use the `module().isEnabled(world)` to make sure this is enforced. ## Code style There is relative freedom when it codes to coding style, but please adhere to the following guidelines: * Use `final` for variables whenever possible. This makes it much less likely to accidentally change a variable and improves code readability. * Use `if !condition return;` pattern to avoid eccessive nested if-statements. That is, to check multiple prerequisite conditions, invert the condition and return, and after returning continue with the code. * Use internal utilies where possible. There is a `Messenger` class for sending messages to users or console, a `Reflector` class for simple reflection, and `DualVersionedMaterial` for support across minecraft versions where the Bukkit item names have changed. There are many more in the `utilities` package, the usage of which can be found in already existing modules. ## Formatting profiles Please use the [default formatting profile](https://www.jetbrains.com/help/idea/reformat-and-rearrange-code.html) provided with IntelliJ. If using a different IDE, here is the [.editconfig](https://www.jetbrains.com/help/idea/configuring-code-style.html#editorconfig) file for those same settings: ``` [*] charset = utf-8 end_of_line = lf indent_size = 4 indent_style = space insert_final_newline = false max_line_length = 120 tab_width = 4 ij_continuation_indent_size = 8 ij_formatter_off_tag = @formatter:off ij_formatter_on_tag = @formatter:on ij_formatter_tags_enabled = false ij_smart_tabs = false ij_visual_guides = none ij_wrap_on_typing = false [*.css] ij_css_align_closing_brace_with_properties = false ij_css_blank_lines_around_nested_selector = 1 ij_css_blank_lines_between_blocks = 1 ij_css_brace_placement = end_of_line ij_css_enforce_quotes_on_format = false ij_css_hex_color_long_format = false ij_css_hex_color_lower_case = false ij_css_hex_color_short_format = false ij_css_hex_color_upper_case = false ij_css_keep_blank_lines_in_code = 2 ij_css_keep_indents_on_empty_lines = false ij_css_keep_single_line_blocks = false ij_css_properties_order = font,font-family,font-size,font-weight,font-style,font-variant,font-size-adjust,font-stretch,line-height,position,z-index,top,right,bottom,left,display,visibility,float,clear,overflow,overflow-x,overflow-y,clip,zoom,align-content,align-items,align-self,flex,flex-flow,flex-basis,flex-direction,flex-grow,flex-shrink,flex-wrap,justify-content,order,box-sizing,width,min-width,max-width,height,min-height,max-height,margin,margin-top,margin-right,margin-bottom,margin-left,padding,padding-top,padding-right,padding-bottom,padding-left,table-layout,empty-cells,caption-side,border-spacing,border-collapse,list-style,list-style-position,list-style-type,list-style-image,content,quotes,counter-reset,counter-increment,resize,cursor,user-select,nav-index,nav-up,nav-right,nav-down,nav-left,transition,transition-delay,transition-timing-function,transition-duration,transition-property,transform,transform-origin,animation,animation-name,animation-duration,animation-play-state,animation-timing-function,animation-delay,animation-iteration-count,animation-direction,text-align,text-align-last,vertical-align,white-space,text-decoration,text-emphasis,text-emphasis-color,text-emphasis-style,text-emphasis-position,text-indent,text-justify,letter-spacing,word-spacing,text-outline,text-transform,text-wrap,text-overflow,text-overflow-ellipsis,text-overflow-mode,word-wrap,word-break,tab-size,hyphens,pointer-events,opacity,color,border,border-width,border-style,border-color,border-top,border-top-width,border-top-style,border-top-color,border-right,border-right-width,border-right-style,border-right-color,border-bottom,border-bottom-width,border-bottom-style,border-bottom-color,border-left,border-left-width,border-left-style,border-left-color,border-radius,border-top-left-radius,border-top-right-radius,border-bottom-right-radius,border-bottom-left-radius,border-image,border-image-source,border-image-slice,border-image-width,border-image-outset,border-image-repeat,outline,outline-width,outline-style,outline-color,outline-offset,background,background-color,background-image,background-repeat,background-attachment,background-position,background-position-x,background-position-y,background-clip,background-origin,background-size,box-decoration-break,box-shadow,text-shadow ij_css_space_after_colon = true ij_css_space_before_opening_brace = true ij_css_use_double_quotes = true ij_css_value_alignment = do_not_align [*.feature] indent_size = 2 ij_gherkin_keep_indents_on_empty_lines = false [*.gsp] ij_gsp_keep_indents_on_empty_lines = false [*.haml] indent_size = 2 ij_haml_keep_indents_on_empty_lines = false [*.java] ij_java_align_consecutive_assignments = false ij_java_align_consecutive_variable_declarations = false ij_java_align_group_field_declarations = false ij_java_align_multiline_annotation_parameters = false ij_java_align_multiline_array_initializer_expression = false ij_java_align_multiline_assignment = false ij_java_align_multiline_binary_operation = false ij_java_align_multiline_chained_methods = false ij_java_align_multiline_extends_list = false ij_java_align_multiline_for = true ij_java_align_multiline_method_parentheses = false ij_java_align_multiline_parameters = true ij_java_align_multiline_parameters_in_calls = false ij_java_align_multiline_parenthesized_expression = false ij_java_align_multiline_records = true ij_java_align_multiline_resources = true ij_java_align_multiline_ternary_operation = false ij_java_align_multiline_text_blocks = false ij_java_align_multiline_throws_list = false ij_java_align_subsequent_simple_methods = false ij_java_align_throws_keyword = false ij_java_annotation_parameter_wrap = off ij_java_array_initializer_new_line_after_left_brace = false ij_java_array_initializer_right_brace_on_new_line = false ij_java_array_initializer_wrap = off ij_java_assert_statement_colon_on_next_line = false ij_java_assert_statement_wrap = off ij_java_assignment_wrap = off ij_java_binary_operation_sign_on_next_line = false ij_java_binary_operation_wrap = off ij_java_blank_lines_after_anonymous_class_header = 0 ij_java_blank_lines_after_class_header = 0 ij_java_blank_lines_after_imports = 1 ij_java_blank_lines_after_package = 1 ij_java_blank_lines_around_class = 1 ij_java_blank_lines_around_field = 0 ij_java_blank_lines_around_field_in_interface = 0 ij_java_blank_lines_around_initializer = 1 ij_java_blank_lines_around_method = 1 ij_java_blank_lines_around_method_in_interface = 1 ij_java_blank_lines_before_class_end = 0 ij_java_blank_lines_before_imports = 1 ij_java_blank_lines_before_method_body = 0 ij_java_blank_lines_before_package = 0 ij_java_block_brace_style = end_of_line ij_java_block_comment_at_first_column = true ij_java_call_parameters_new_line_after_left_paren = false ij_java_call_parameters_right_paren_on_new_line = false ij_java_call_parameters_wrap = off ij_java_case_statement_on_separate_line = true ij_java_catch_on_new_line = false ij_java_class_annotation_wrap = split_into_lines ij_java_class_brace_style = end_of_line ij_java_class_count_to_use_import_on_demand = 5 ij_java_class_names_in_javadoc = 1 ij_java_do_not_indent_top_level_class_members = false ij_java_do_not_wrap_after_single_annotation = false ij_java_do_while_brace_force = never ij_java_doc_add_blank_line_after_description = true ij_java_doc_add_blank_line_after_param_comments = false ij_java_doc_add_blank_line_after_return = false ij_java_doc_add_p_tag_on_empty_lines = true ij_java_doc_align_exception_comments = true ij_java_doc_align_param_comments = true ij_java_doc_do_not_wrap_if_one_line = false ij_java_doc_enable_formatting = true ij_java_doc_enable_leading_asterisks = true ij_java_doc_indent_on_continuation = false ij_java_doc_keep_empty_lines = true ij_java_doc_keep_empty_parameter_tag = true ij_java_doc_keep_empty_return_tag = true ij_java_doc_keep_empty_throws_tag = true ij_java_doc_keep_invalid_tags = true ij_java_doc_param_description_on_new_line = false ij_java_doc_preserve_line_breaks = false ij_java_doc_use_throws_not_exception_tag = true ij_java_else_on_new_line = false ij_java_entity_dd_suffix = EJB ij_java_entity_eb_suffix = Bean ij_java_entity_hi_suffix = Home ij_java_entity_lhi_prefix = Local ij_java_entity_lhi_suffix = Home ij_java_entity_li_prefix = Local ij_java_entity_pk_class = java.lang.String ij_java_entity_vo_suffix = VO ij_java_enum_constants_wrap = off ij_java_extends_keyword_wrap = off ij_java_extends_list_wrap = off ij_java_field_annotation_wrap = split_into_lines ij_java_finally_on_new_line = false ij_java_for_brace_force = never ij_java_for_statement_new_line_after_left_paren = false ij_java_for_statement_right_paren_on_new_line = false ij_java_for_statement_wrap = off ij_java_generate_final_locals = false ij_java_generate_final_parameters = false ij_java_if_brace_force = never ij_java_imports_layout = *,|,javax.**,java.**,|,$* ij_java_indent_case_from_switch = true ij_java_insert_inner_class_imports = false ij_java_insert_override_annotation = true ij_java_keep_blank_lines_before_right_brace = 2 ij_java_keep_blank_lines_between_package_declaration_and_header = 2 ij_java_keep_blank_lines_in_code = 2 ij_java_keep_blank_lines_in_declarations = 2 ij_java_keep_control_statement_in_one_line = true ij_java_keep_first_column_comment = true ij_java_keep_indents_on_empty_lines = false ij_java_keep_line_breaks = true ij_java_keep_multiple_expressions_in_one_line = false ij_java_keep_simple_blocks_in_one_line = false ij_java_keep_simple_classes_in_one_line = false ij_java_keep_simple_lambdas_in_one_line = false ij_java_keep_simple_methods_in_one_line = false ij_java_label_indent_absolute = false ij_java_label_indent_size = 0 ij_java_lambda_brace_style = end_of_line ij_java_layout_static_imports_separately = true ij_java_line_comment_add_space = false ij_java_line_comment_at_first_column = true ij_java_message_dd_suffix = EJB ij_java_message_eb_suffix = Bean ij_java_method_annotation_wrap = split_into_lines ij_java_method_brace_style = end_of_line ij_java_method_call_chain_wrap = off ij_java_method_parameters_new_line_after_left_paren = false ij_java_method_parameters_right_paren_on_new_line = false ij_java_method_parameters_wrap = off ij_java_modifier_list_wrap = false ij_java_names_count_to_use_import_on_demand = 3 ij_java_new_line_after_lparen_in_record_header = false ij_java_packages_to_use_import_on_demand = java.awt.*,javax.swing.* ij_java_parameter_annotation_wrap = off ij_java_parentheses_expression_new_line_after_left_paren = false ij_java_parentheses_expression_right_paren_on_new_line = false ij_java_place_assignment_sign_on_next_line = false ij_java_prefer_longer_names = true ij_java_prefer_parameters_wrap = false ij_java_record_components_wrap = normal ij_java_repeat_synchronized = true ij_java_replace_instanceof_and_cast = false ij_java_replace_null_check = true ij_java_replace_sum_lambda_with_method_ref = true ij_java_resource_list_new_line_after_left_paren = false ij_java_resource_list_right_paren_on_new_line = false ij_java_resource_list_wrap = off ij_java_rparen_on_new_line_in_record_header = false ij_java_session_dd_suffix = EJB ij_java_session_eb_suffix = Bean ij_java_session_hi_suffix = Home ij_java_session_lhi_prefix = Local ij_java_session_lhi_suffix = Home ij_java_session_li_prefix = Local ij_java_session_si_suffix = Service ij_java_space_after_closing_angle_bracket_in_type_argument = false ij_java_space_after_colon = true ij_java_space_after_comma = true ij_java_space_after_comma_in_type_arguments = true ij_java_space_after_for_semicolon = true ij_java_space_after_quest = true ij_java_space_after_type_cast = true ij_java_space_before_annotation_array_initializer_left_brace = false ij_java_space_before_annotation_parameter_list = false ij_java_space_before_array_initializer_left_brace = false ij_java_space_before_catch_keyword = true ij_java_space_before_catch_left_brace = true ij_java_space_before_catch_parentheses = true ij_java_space_before_class_left_brace = true ij_java_space_before_colon = true ij_java_space_before_colon_in_foreach = true ij_java_space_before_comma = false ij_java_space_before_do_left_brace = true ij_java_space_before_else_keyword = true ij_java_space_before_else_left_brace = true ij_java_space_before_finally_keyword = true ij_java_space_before_finally_left_brace = true ij_java_space_before_for_left_brace = true ij_java_space_before_for_parentheses = true ij_java_space_before_for_semicolon = false ij_java_space_before_if_left_brace = true ij_java_space_before_if_parentheses = true ij_java_space_before_method_call_parentheses = false ij_java_space_before_method_left_brace = true ij_java_space_before_method_parentheses = false ij_java_space_before_opening_angle_bracket_in_type_parameter = false ij_java_space_before_quest = true ij_java_space_before_switch_left_brace = true ij_java_space_before_switch_parentheses = true ij_java_space_before_synchronized_left_brace = true ij_java_space_before_synchronized_parentheses = true ij_java_space_before_try_left_brace = true ij_java_space_before_try_parentheses = true ij_java_space_before_type_parameter_list = false ij_java_space_before_while_keyword = true ij_java_space_before_while_left_brace = true ij_java_space_before_while_parentheses = true ij_java_space_inside_one_line_enum_braces = false ij_java_space_within_empty_array_initializer_braces = false ij_java_space_within_empty_method_call_parentheses = false ij_java_space_within_empty_method_parentheses = false ij_java_spaces_around_additive_operators = true ij_java_spaces_around_assignment_operators = true ij_java_spaces_around_bitwise_operators = true ij_java_spaces_around_equality_operators = true ij_java_spaces_around_lambda_arrow = true ij_java_spaces_around_logical_operators = true ij_java_spaces_around_method_ref_dbl_colon = false ij_java_spaces_around_multiplicative_operators = true ij_java_spaces_around_relational_operators = true ij_java_spaces_around_shift_operators = true ij_java_spaces_around_type_bounds_in_type_parameters = true ij_java_spaces_around_unary_operator = false ij_java_spaces_within_angle_brackets = false ij_java_spaces_within_annotation_parentheses = false ij_java_spaces_within_array_initializer_braces = false ij_java_spaces_within_braces = false ij_java_spaces_within_brackets = false ij_java_spaces_within_cast_parentheses = false ij_java_spaces_within_catch_parentheses = false ij_java_spaces_within_for_parentheses = false ij_java_spaces_within_if_parentheses = false ij_java_spaces_within_method_call_parentheses = false ij_java_spaces_within_method_parentheses = false ij_java_spaces_within_parentheses = false ij_java_spaces_within_record_header = false ij_java_spaces_within_switch_parentheses = false ij_java_spaces_within_synchronized_parentheses = false ij_java_spaces_within_try_parentheses = false ij_java_spaces_within_while_parentheses = false ij_java_special_else_if_treatment = true ij_java_subclass_name_suffix = Impl ij_java_ternary_operation_signs_on_next_line = false ij_java_ternary_operation_wrap = off ij_java_test_name_suffix = Test ij_java_throws_keyword_wrap = off ij_java_throws_list_wrap = off ij_java_use_external_annotations = false ij_java_use_fq_class_names = false ij_java_use_relative_indents = false ij_java_use_single_class_imports = true ij_java_variable_annotation_wrap = off ij_java_visibility = public ij_java_while_brace_force = never ij_java_while_on_new_line = false ij_java_wrap_comments = false ij_java_wrap_first_method_in_call_chain = false ij_java_wrap_long_lines = false [.editorconfig] ij_editorconfig_align_group_field_declarations = false ij_editorconfig_space_after_colon = false ij_editorconfig_space_after_comma = true ij_editorconfig_space_before_colon = false ij_editorconfig_space_before_comma = false ij_editorconfig_spaces_around_assignment_operators = true [{*.ant,*.fxml,*.jhm,*.jnlp,*.jrxml,*.pom,*.qrc,*.rng,*.tld,*.wadl,*.wsdd,*.wsdl,*.xjb,*.xml,*.xsd,*.xsl,*.xslt,*.xul}] ij_xml_align_attributes = true ij_xml_align_text = false ij_xml_attribute_wrap = normal ij_xml_block_comment_at_first_column = true ij_xml_keep_blank_lines = 2 ij_xml_keep_indents_on_empty_lines = false ij_xml_keep_line_breaks = true ij_xml_keep_line_breaks_in_text = true ij_xml_keep_whitespaces = false ij_xml_keep_whitespaces_around_cdata = preserve ij_xml_keep_whitespaces_inside_cdata = false ij_xml_line_comment_at_first_column = true ij_xml_space_after_tag_name = false ij_xml_space_around_equals_in_attribute = false ij_xml_space_inside_empty_tag = false ij_xml_text_wrap = normal ij_xml_use_custom_settings = false [{*.ft,*.vm,*.vsl}] ij_vtl_keep_indents_on_empty_lines = false [{*.gant,*.gradle,*.groovy,*.gson,*.gy}] ij_groovy_align_group_field_declarations = false ij_groovy_align_multiline_array_initializer_expression = false ij_groovy_align_multiline_assignment = false ij_groovy_align_multiline_binary_operation = false ij_groovy_align_multiline_chained_methods = false ij_groovy_align_multiline_extends_list = false ij_groovy_align_multiline_for = true ij_groovy_align_multiline_list_or_map = true ij_groovy_align_multiline_method_parentheses = false ij_groovy_align_multiline_parameters = true ij_groovy_align_multiline_parameters_in_calls = false ij_groovy_align_multiline_resources = true ij_groovy_align_multiline_ternary_operation = false ij_groovy_align_multiline_throws_list = false ij_groovy_align_named_args_in_map = true ij_groovy_align_throws_keyword = false ij_groovy_array_initializer_new_line_after_left_brace = false ij_groovy_array_initializer_right_brace_on_new_line = false ij_groovy_array_initializer_wrap = off ij_groovy_assert_statement_wrap = off ij_groovy_assignment_wrap = off ij_groovy_binary_operation_wrap = off ij_groovy_blank_lines_after_class_header = 0 ij_groovy_blank_lines_after_imports = 1 ij_groovy_blank_lines_after_package = 1 ij_groovy_blank_lines_around_class = 1 ij_groovy_blank_lines_around_field = 0 ij_groovy_blank_lines_around_field_in_interface = 0 ij_groovy_blank_lines_around_method = 1 ij_groovy_blank_lines_around_method_in_interface = 1 ij_groovy_blank_lines_before_imports = 1 ij_groovy_blank_lines_before_method_body = 0 ij_groovy_blank_lines_before_package = 0 ij_groovy_block_brace_style = end_of_line ij_groovy_block_comment_at_first_column = true ij_groovy_call_parameters_new_line_after_left_paren = false ij_groovy_call_parameters_right_paren_on_new_line = false ij_groovy_call_parameters_wrap = off ij_groovy_catch_on_new_line = false ij_groovy_class_annotation_wrap = split_into_lines ij_groovy_class_brace_style = end_of_line ij_groovy_class_count_to_use_import_on_demand = 5 ij_groovy_do_while_brace_force = never ij_groovy_else_on_new_line = false ij_groovy_enum_constants_wrap = off ij_groovy_extends_keyword_wrap = off ij_groovy_extends_list_wrap = off ij_groovy_field_annotation_wrap = split_into_lines ij_groovy_finally_on_new_line = false ij_groovy_for_brace_force = never ij_groovy_for_statement_new_line_after_left_paren = false ij_groovy_for_statement_right_paren_on_new_line = false ij_groovy_for_statement_wrap = off ij_groovy_if_brace_force = never ij_groovy_import_annotation_wrap = 2 ij_groovy_imports_layout = *,|,javax.**,java.**,|,$* ij_groovy_indent_case_from_switch = true ij_groovy_indent_label_blocks = true ij_groovy_insert_inner_class_imports = false ij_groovy_keep_blank_lines_before_right_brace = 2 ij_groovy_keep_blank_lines_in_code = 2 ij_groovy_keep_blank_lines_in_declarations = 2 ij_groovy_keep_control_statement_in_one_line = true ij_groovy_keep_first_column_comment = true ij_groovy_keep_indents_on_empty_lines = false ij_groovy_keep_line_breaks = true ij_groovy_keep_multiple_expressions_in_one_line = false ij_groovy_keep_simple_blocks_in_one_line = false ij_groovy_keep_simple_classes_in_one_line = true ij_groovy_keep_simple_lambdas_in_one_line = true ij_groovy_keep_simple_methods_in_one_line = true ij_groovy_label_indent_absolute = false ij_groovy_label_indent_size = 0 ij_groovy_lambda_brace_style = end_of_line ij_groovy_layout_static_imports_separately = true ij_groovy_line_comment_add_space = false ij_groovy_line_comment_at_first_column = true ij_groovy_method_annotation_wrap = split_into_lines ij_groovy_method_brace_style = end_of_line ij_groovy_method_call_chain_wrap = off ij_groovy_method_parameters_new_line_after_left_paren = false ij_groovy_method_parameters_right_paren_on_new_line = false ij_groovy_method_parameters_wrap = off ij_groovy_modifier_list_wrap = false ij_groovy_names_count_to_use_import_on_demand = 3 ij_groovy_parameter_annotation_wrap = off ij_groovy_parentheses_expression_new_line_after_left_paren = false ij_groovy_parentheses_expression_right_paren_on_new_line = false ij_groovy_prefer_parameters_wrap = false ij_groovy_resource_list_new_line_after_left_paren = false ij_groovy_resource_list_right_paren_on_new_line = false ij_groovy_resource_list_wrap = off ij_groovy_space_after_assert_separator = true ij_groovy_space_after_colon = true ij_groovy_space_after_comma = true ij_groovy_space_after_comma_in_type_arguments = true ij_groovy_space_after_for_semicolon = true ij_groovy_space_after_quest = true ij_groovy_space_after_type_cast = true ij_groovy_space_before_annotation_parameter_list = false ij_groovy_space_before_array_initializer_left_brace = false ij_groovy_space_before_assert_separator = false ij_groovy_space_before_catch_keyword = true ij_groovy_space_before_catch_left_brace = true ij_groovy_space_before_catch_parentheses = true ij_groovy_space_before_class_left_brace = true ij_groovy_space_before_closure_left_brace = true ij_groovy_space_before_colon = true ij_groovy_space_before_comma = false ij_groovy_space_before_do_left_brace = true ij_groovy_space_before_else_keyword = true ij_groovy_space_before_else_left_brace = true ij_groovy_space_before_finally_keyword = true ij_groovy_space_before_finally_left_brace = true ij_groovy_space_before_for_left_brace = true ij_groovy_space_before_for_parentheses = true ij_groovy_space_before_for_semicolon = false ij_groovy_space_before_if_left_brace = true ij_groovy_space_before_if_parentheses = true ij_groovy_space_before_method_call_parentheses = false ij_groovy_space_before_method_left_brace = true ij_groovy_space_before_method_parentheses = false ij_groovy_space_before_quest = true ij_groovy_space_before_switch_left_brace = true ij_groovy_space_before_switch_parentheses = true ij_groovy_space_before_synchronized_left_brace = true ij_groovy_space_before_synchronized_parentheses = true ij_groovy_space_before_try_left_brace = true ij_groovy_space_before_try_parentheses = true ij_groovy_space_before_while_keyword = true ij_groovy_space_before_while_left_brace = true ij_groovy_space_before_while_parentheses = true ij_groovy_space_in_named_argument = true ij_groovy_space_in_named_argument_before_colon = false ij_groovy_space_within_empty_array_initializer_braces = false ij_groovy_space_within_empty_method_call_parentheses = false ij_groovy_spaces_around_additive_operators = true ij_groovy_spaces_around_assignment_operators = true ij_groovy_spaces_around_bitwise_operators = true ij_groovy_spaces_around_equality_operators = true ij_groovy_spaces_around_lambda_arrow = true ij_groovy_spaces_around_logical_operators = true ij_groovy_spaces_around_multiplicative_operators = true ij_groovy_spaces_around_regex_operators = true ij_groovy_spaces_around_relational_operators = true ij_groovy_spaces_around_shift_operators = true ij_groovy_spaces_within_annotation_parentheses = false ij_groovy_spaces_within_array_initializer_braces = false ij_groovy_spaces_within_braces = true ij_groovy_spaces_within_brackets = false ij_groovy_spaces_within_cast_parentheses = false ij_groovy_spaces_within_catch_parentheses = false ij_groovy_spaces_within_for_parentheses = false ij_groovy_spaces_within_gstring_injection_braces = false ij_groovy_spaces_within_if_parentheses = false ij_groovy_spaces_within_list_or_map = false ij_groovy_spaces_within_method_call_parentheses = false ij_groovy_spaces_within_method_parentheses = false ij_groovy_spaces_within_parentheses = false ij_groovy_spaces_within_switch_parentheses = false ij_groovy_spaces_within_synchronized_parentheses = false ij_groovy_spaces_within_try_parentheses = false ij_groovy_spaces_within_tuple_expression = false ij_groovy_spaces_within_while_parentheses = false ij_groovy_special_else_if_treatment = true ij_groovy_ternary_operation_wrap = off ij_groovy_throws_keyword_wrap = off ij_groovy_throws_list_wrap = off ij_groovy_use_flying_geese_braces = false ij_groovy_use_fq_class_names = false ij_groovy_use_fq_class_names_in_javadoc = true ij_groovy_use_relative_indents = false ij_groovy_use_single_class_imports = true ij_groovy_variable_annotation_wrap = off ij_groovy_while_brace_force = never ij_groovy_while_on_new_line = false ij_groovy_wrap_long_lines = false [{*.gradle.kts,*.kt,*.kts,*.main.kts}] ij_kotlin_align_in_columns_case_branch = false ij_kotlin_align_multiline_binary_operation = false ij_kotlin_align_multiline_extends_list = false ij_kotlin_align_multiline_method_parentheses = false ij_kotlin_align_multiline_parameters = true ij_kotlin_align_multiline_parameters_in_calls = false ij_kotlin_allow_trailing_comma = false ij_kotlin_allow_trailing_comma_on_call_site = false ij_kotlin_assignment_wrap = normal ij_kotlin_blank_lines_after_class_header = 0 ij_kotlin_blank_lines_around_block_when_branches = 0 ij_kotlin_blank_lines_before_declaration_with_comment_or_annotation_on_separate_line = 1 ij_kotlin_block_comment_at_first_column = true ij_kotlin_call_parameters_new_line_after_left_paren = true ij_kotlin_call_parameters_right_paren_on_new_line = true ij_kotlin_call_parameters_wrap = on_every_item ij_kotlin_catch_on_new_line = false ij_kotlin_class_annotation_wrap = split_into_lines ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL ij_kotlin_continuation_indent_for_chained_calls = false ij_kotlin_continuation_indent_for_expression_bodies = false ij_kotlin_continuation_indent_in_argument_lists = false ij_kotlin_continuation_indent_in_elvis = false ij_kotlin_continuation_indent_in_if_conditions = false ij_kotlin_continuation_indent_in_parameter_lists = false ij_kotlin_continuation_indent_in_supertype_lists = false ij_kotlin_else_on_new_line = false ij_kotlin_enum_constants_wrap = off ij_kotlin_extends_list_wrap = normal ij_kotlin_field_annotation_wrap = split_into_lines ij_kotlin_finally_on_new_line = false ij_kotlin_if_rparen_on_new_line = true ij_kotlin_import_nested_classes = false ij_kotlin_imports_layout = *,java.**,javax.**,kotlin.**,^ ij_kotlin_insert_whitespaces_in_simple_one_line_method = true ij_kotlin_keep_blank_lines_before_right_brace = 2 ij_kotlin_keep_blank_lines_in_code = 2 ij_kotlin_keep_blank_lines_in_declarations = 2 ij_kotlin_keep_first_column_comment = true ij_kotlin_keep_indents_on_empty_lines = false ij_kotlin_keep_line_breaks = true ij_kotlin_lbrace_on_next_line = false ij_kotlin_line_comment_add_space = false ij_kotlin_line_comment_at_first_column = true ij_kotlin_method_annotation_wrap = split_into_lines ij_kotlin_method_call_chain_wrap = normal ij_kotlin_method_parameters_new_line_after_left_paren = true ij_kotlin_method_parameters_right_paren_on_new_line = true ij_kotlin_method_parameters_wrap = on_every_item ij_kotlin_name_count_to_use_star_import = 5 ij_kotlin_name_count_to_use_star_import_for_members = 3 ij_kotlin_packages_to_use_import_on_demand = java.util.*,kotlinx.android.synthetic.**,io.ktor.** ij_kotlin_parameter_annotation_wrap = off ij_kotlin_space_after_comma = true ij_kotlin_space_after_extend_colon = true ij_kotlin_space_after_type_colon = true ij_kotlin_space_before_catch_parentheses = true ij_kotlin_space_before_comma = false ij_kotlin_space_before_extend_colon = true ij_kotlin_space_before_for_parentheses = true ij_kotlin_space_before_if_parentheses = true ij_kotlin_space_before_lambda_arrow = true ij_kotlin_space_before_type_colon = false ij_kotlin_space_before_when_parentheses = true ij_kotlin_space_before_while_parentheses = true ij_kotlin_spaces_around_additive_operators = true ij_kotlin_spaces_around_assignment_operators = true ij_kotlin_spaces_around_equality_operators = true ij_kotlin_spaces_around_function_type_arrow = true ij_kotlin_spaces_around_logical_operators = true ij_kotlin_spaces_around_multiplicative_operators = true ij_kotlin_spaces_around_range = false ij_kotlin_spaces_around_relational_operators = true ij_kotlin_spaces_around_unary_operator = false ij_kotlin_spaces_around_when_arrow = true ij_kotlin_variable_annotation_wrap = off ij_kotlin_while_on_new_line = false ij_kotlin_wrap_elvis_expressions = 1 ij_kotlin_wrap_expression_body_functions = 1 ij_kotlin_wrap_first_method_in_call_chain = false [{*.htm,*.html,*.ng,*.sht,*.shtm,*.shtml}] ij_html_add_new_line_before_tags = body,div,p,form,h1,h2,h3 ij_html_align_attributes = true ij_html_align_text = false ij_html_attribute_wrap = normal ij_html_block_comment_at_first_column = true ij_html_do_not_align_children_of_min_lines = 0 ij_html_do_not_break_if_inline_tags = title,h1,h2,h3,h4,h5,h6,p ij_html_do_not_indent_children_of_tags = html,body,thead,tbody,tfoot ij_html_enforce_quotes = false ij_html_inline_tags = a,abbr,acronym,b,basefont,bdo,big,br,cite,cite,code,dfn,em,font,i,img,input,kbd,label,q,s,samp,select,small,span,strike,strong,sub,sup,textarea,tt,u,var ij_html_keep_blank_lines = 2 ij_html_keep_indents_on_empty_lines = false ij_html_keep_line_breaks = true ij_html_keep_line_breaks_in_text = true ij_html_keep_whitespaces = false ij_html_keep_whitespaces_inside = span,pre,textarea ij_html_line_comment_at_first_column = true ij_html_new_line_after_last_attribute = never ij_html_new_line_before_first_attribute = never ij_html_quote_style = double ij_html_remove_new_line_before_tags = br ij_html_space_after_tag_name = false ij_html_space_around_equality_in_attribute = false ij_html_space_inside_empty_tag = false ij_html_text_wrap = normal ij_html_uniform_ident = false [{*.markdown,*.md}] ij_markdown_force_one_space_after_blockquote_symbol = true ij_markdown_force_one_space_after_header_symbol = true ij_markdown_force_one_space_after_list_bullet = true ij_markdown_force_one_space_between_words = true ij_markdown_keep_indents_on_empty_lines = false ij_markdown_max_lines_around_block_elements = 1 ij_markdown_max_lines_around_header = 1 ij_markdown_max_lines_between_paragraphs = 1 ij_markdown_min_lines_around_block_elements = 1 ij_markdown_min_lines_around_header = 1 ij_markdown_min_lines_between_paragraphs = 1 [{*.properties,spring.handlers,spring.schemas}] ij_properties_align_group_field_declarations = false ij_properties_keep_blank_lines = false ij_properties_key_value_delimiter = equals ij_properties_spaces_around_key_value_delimiter = false [{*.yaml,*.yml}] indent_size = 2 ij_yaml_keep_indents_on_empty_lines = false ij_yaml_keep_line_breaks = true ij_yaml_space_before_colon = true ij_yaml_spaces_within_braces = true ij_yaml_spaces_within_brackets = true ``` ================================================ FILE: .github/ISSUE_TEMPLATE/1-bug-report.yaml ================================================ name: Bug Report description: Report a bug in the plugin labels: ["bug", "investigate"] body: - type: markdown attributes: value: | ## ⚠️ PLEASE READ BEFORE SUBMITTING ⚠️ 1. Try the [latest test version](https://hangar.papermc.io/kernitus/OldCombatMechanics/versions?channel=Snapshot&platform=PAPER) first 2. Complete ALL fields below - incomplete reports will be CLOSED 3. This is a volunteer project - we have no obligation to help incomplete reports 4. Have a question? Please use the Question template instead - type: input id: server-version attributes: label: Server Version description: Version of the server, e.g. Spigot 1.14.1 or Paper 1.19.3 placeholder: e.g. Paper 1.20.4 validations: required: true - type: input id: ocm-version attributes: label: OldCombatMechanics Version description: "EXACT version of OldCombatMechanics, e.g. 1.7.2 or 2.1.1-beta+e2f0369. DO NOT write 'latest' - versions change often." placeholder: e.g. 2.1.1-beta+e2f0369 validations: required: true - type: textarea id: server-log attributes: label: Server Log File description: Console log from the server. DO NOT use an external service like pastebin, as these expire. placeholder: Paste your log here render: console validations: required: true - type: textarea id: config attributes: label: OldCombatMechanics config.yml description: Your config file. DO NOT use an external service like pastebin, as these expire. placeholder: Paste your config.yml here render: yaml validations: required: true - type: textarea id: other-plugins attributes: label: Other Plugins description: List of other plugins installed (conflicts are common) placeholder: | - ViaVersion 1.0.0 - AnotherPlugin 2.3.1 validations: required: true - type: textarea id: problem-description attributes: label: Problem Description description: A clear and concise description of what the bug is validations: required: true - type: textarea id: reproduce attributes: label: Steps to Reproduce description: What you would do in order for the problem to occur placeholder: | 1. Hit a mob with a stick 2. 3. validations: required: true - type: textarea id: expected attributes: label: Expected Behaviour description: What do you think should happen when you perform the above steps? validations: required: true - type: textarea id: actual attributes: label: Actual Behaviour description: What does happen when you perform the above steps? validations: required: true - type: textarea id: additional attributes: label: Additional Context description: Add any other context, screenshots, or videos here - type: checkboxes id: confirmation attributes: label: Pre-submission checklist options: - label: I have tried the latest test/snapshot version required: true - label: I have filled out all required fields below required: true ================================================ FILE: .github/ISSUE_TEMPLATE/2-question.yaml ================================================ name: Question description: Ask a question about the plugin labels: ["question"] body: - type: markdown attributes: value: | ## ⚠️ PLEASE READ BEFORE SUBMITTING ⚠️ 1. Check the readme and wiki first: https://github.com/kernitus/BukkitOldCombatMechanics/wiki 2. Search existing issues to see if your question has been answered 3. This is a volunteer project - we have no obligation to help incomplete reports 4. If you've found a bug, use the Bug Report template instead 5. If you want a new feature, use the Feature Request template instead - type: checkboxes id: confirmation attributes: label: Pre-submission checklist options: - label: I have checked the wiki and readme required: true - label: I have searched existing issues required: true - type: textarea id: question attributes: label: Your Question description: Clearly describe what you want to know validations: required: true - type: textarea id: tried attributes: label: What I've Tried description: Have you checked documentation? Tried anything? Searched for similar issues? validations: required: true - type: input id: server-version attributes: label: Server Version placeholder: e.g. Paper 1.20.4 validations: required: true - type: input id: ocm-version attributes: label: OldCombatMechanics Version description: "DO NOT write 'latest' - specify the exact version number" placeholder: e.g. 2.1.1 validations: required: true - type: textarea id: context attributes: label: Additional Context description: Any other relevant information, screenshots, config snippets, etc. ================================================ FILE: .github/ISSUE_TEMPLATE/3-feature.yaml ================================================ name: Feature Request description: Suggest an idea for this project labels: ["enhancement"] body: - type: markdown attributes: value: | ## ⚠️ PLEASE READ BEFORE SUBMITTING ⚠️ 1. Search for existing enhancement requests first 2. Have a question? Please use the Question template instead 3. This plugin is about combat mechanics changes from 1.9+ - not general Minecraft features 4. Incomplete requests WILL be closed - this is a volunteer project Remember that this plugin is about changes in combat mechanics following 1.8, anything else is out of scope. - type: checkboxes id: confirmation attributes: label: Pre-submission checklist options: - label: I have searched for existing enhancement requests required: true - label: This relates to combat mechanics changes from 1.9+ required: true - type: textarea id: problem attributes: label: Problem description: Describe the problem you are facing, as a consequence of a lack of features rather than a bug validations: required: true - type: textarea id: solution attributes: label: Proposed Solution description: The solution you think best for the problem validations: required: true - type: textarea id: alternatives attributes: label: Alternative Solutions description: Describe alternative solutions you have considered validations: required: false - type: textarea id: evidence attributes: label: Evidence of Mechanic Change description: If your enhancement is about a combat feature that changed between 1.8 and now, provide evidence (wiki links, videos, etc.) placeholder: Links to Minecraft wiki, videos demonstrating the mechanic, etc. validations: required: false - type: textarea id: additional attributes: label: Additional Context description: Any other context or screenshots that could be relevant ================================================ FILE: .github/ISSUE_TEMPLATE/config.yml ================================================ blank_issues_enabled: false ================================================ FILE: .github/release-please-config.json ================================================ { "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json", "include-component-in-tag": false, "bump-minor-pre-major": true, "bootstrap-sha": "56dd66a4bf88f252bb063b91835d89a1a1a2e442", "packages": { ".": { "package-name": "OldCombatMechanics", "release-type": "simple", "extra-files": [ { "type": "generic", "path": "build.gradle.kts" } ], "changelog-sections": [ {"type": "feat", "section": "Features"}, {"type": "fix", "section": "Bug Fixes"}, {"type": "perf", "section": "Performance"} ] } } } ================================================ FILE: .github/release-please-manifest.json ================================================ {".":"2.4.0"} ================================================ FILE: .github/workflows/build-upload-release.yml ================================================ name: Build and Release on: release: types: [published] jobs: build: # This permission is still required by the new action permissions: contents: write runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v4 - name: Set up JDK 17 uses: actions/setup-java@v4 with: java-version: '17' distribution: 'adopt' - name: Setup Gradle uses: gradle/actions/setup-gradle@v4 with: gradle-version: wrapper # Build Step - No changes needed here - name: Run Gradle Build run: | if [ "${{ github.event_name }}" == "release" ]; then VERSION=${{ github.event.release.tag_name }} VERSION=${VERSION#v} # Strip 'v' if present ./gradlew clean build -Pversion=$VERSION else ./gradlew clean build fi - name: Upload Artifact to GitHub Release if: ${{ github.event_name == 'release' }} uses: softprops/action-gh-release@v2 with: # The 'files' input takes a path to the asset(s) you want to upload. # Keep a stable filename for external download links. files: ./build/libs/OldCombatMechanics.jar - name: Read game versions from gradle.properties run: | RAW=$(grep ^gameVersions gradle.properties | cut -d'=' -f2-) # Convert "1.21, 1.20.6" -> "1:1.21,1:1.20.6" to select Bukkit-compatible typeId 1 entries via the minecraft endpoint GAME_VERSIONS=$(echo "$RAW" | tr -d ' ' | awk -F',' '{ out=""; for (i=1; i<=NF; i++) { v=$i; if (v!= "") { if (out!= "") out=out ","; out=out "1:" v; } } print out; }') echo "GAME_VERSIONS=$GAME_VERSIONS" >> "$GITHUB_ENV" - name: Upload to CurseForge (Bukkit) if: ${{ github.event_name == 'release' }} uses: itsmeow/curseforge-upload@v3 with: token: ${{ secrets.DBO_UPLOAD_API_TOKEN }} project_id: '98233' game_endpoint: 'minecraft' file_path: './build/libs/OldCombatMechanics.jar' changelog: ${{ github.event.release.body }} changelog_type: 'markdown' release_type: 'release' display_name: 'OldCombatMechanics ${{ github.event.release.tag_name }}' game_versions: ${{ env.GAME_VERSIONS }} - name: Publish to Hangar env: HANGAR_API_TOKEN: ${{ secrets.HANGAR_API_TOKEN }} HANGAR_CHANGELOG: ${{ github.event.release.body }} run: ./gradlew build publishPluginPublicationToHangar --stacktrace ================================================ FILE: .github/workflows/dev-builds.yml ================================================ name: Dev builds on: push: branches: - master pull_request: branches-ignore: - 'ingametesting' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 - name: Set up JDK 17 uses: actions/setup-java@v4 with: java-version: '17' distribution: 'adopt' cache: gradle - name: Setup Gradle uses: gradle/actions/setup-gradle@v4 with: gradle-version: wrapper - name: Determine if this is a release version run: | IS_RELEASE=$(./gradlew -q printIsRelease) echo "Is release? $IS_RELEASE" echo "IS_RELEASE=$IS_RELEASE" >> $GITHUB_ENV - name: Run Gradle Build run: | ./gradlew clean build - name: Archive jar file uses: actions/upload-artifact@v4 with: name: OldCombatMechanics path: build/libs/OldCombatMechanics.jar - name: Publish Snapshot to Hangar if: ${{ github.event_name == 'push' && github.event.pull_request == null && env.IS_RELEASE != 'true' }} env: HANGAR_API_TOKEN: ${{ secrets.HANGAR_API_TOKEN }} run: | ./gradlew publishPluginPublicationToHangar ================================================ FILE: .github/workflows/release-please.yml ================================================ name: Release Please on: push: branches: - master permissions: contents: write pull-requests: write jobs: release: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: release-please uses: googleapis/release-please-action@v4 with: token: ${{ secrets.RELEASE_PLEASE_TOKEN }} config-file: .github/release-please-config.json manifest-file: .github/release-please-manifest.json ================================================ FILE: .github/workflows/wrap-issue-form-codeblocks.yml ================================================ name: Wrap issue form code blocks on: issues: types: [opened, edited] permissions: issues: write jobs: wrap: runs-on: ubuntu-latest steps: - uses: actions/github-script@v8 with: script: | // Avoid loops: when this workflow updates the issue, it triggers "edited" again. if (context.actor === "github-actions[bot]") return; const issue = context.payload.issue; if (!issue || !issue.body) return; // On edits, bail unless the body actually changed if (context.payload.action === "edited") { const changed = context.payload.changes && context.payload.changes.body; if (!changed) return; } function escapeRegExp(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); } function wrapFirstCodeBlockAfterHeading(body, headingText, summaryText) { const re = new RegExp( `(^###\\s+${escapeRegExp(headingText)}\\s*\\n+)(\`\`\`[\\s\\S]*?\\n\`\`\`)(?=\\n|$)`, "m" ); return body.replace(re, (_m, heading, codeblock) => { return ( `${heading}` + `
\n` + `${summaryText}\n\n` + `${codeblock}\n\n` + `
` ); }); } let body = issue.body; body = wrapFirstCodeBlockAfterHeading(body, "Server Log File", "Server log"); body = wrapFirstCodeBlockAfterHeading(body, "OldCombatMechanics config.yml", "config.yml"); if (body === issue.body) return; await github.rest.issues.update({ owner: context.repo.owner, repo: context.repo.repo, issue_number: issue.number, body }); ================================================ FILE: .gitignore ================================================ # === # == IDE settings files # === # IntelliJ /*.eml /*.iml /.idea # Eclipse /.project /.classpath /.settings # === # == Compilation output / working files # === out builds target META-INF /build/ /gradle/ /.gradle/ .gradle-user/ /.gradle-cache/ /.gradle-local/ kls-classpath kls_database.db /run/ /bin/ .opencode/ ================================================ FILE: AGENTS.md ================================================ # AGENTS.md **Prime directive:** If you are reading this file, it is your responsibility as an agent to keep it up to date with any changes you make in this repository. This file captures repo-specific context discovered while working on this branch. ## Repo overview - Project: OldCombatMechanics (Bukkit/Paper plugin) - Branch context: working from `kotlin-tests` branch - Build tool: Gradle (wrapper currently at 9.2.1) - JDKs used locally: 8, 11, 17, 25 ## Integration test harness (Kotlin) - Integration tests live in `src/integrationTest/kotlin` and are packaged into `OldCombatMechanics--tests.jar`. - Entrypoint plugin class: `kernitus.plugin.OldCombatMechanics.OCMTestMain`. - Tests run inside a real Paper server started by the Gradle `run-paper` plugin. - RunServer output is redirected to `build/integration-test-logs/.log`; `checkTestResults` prints only a compact summary/failures to the console. - `KotestRunner` writes a compact `plugins/OldCombatMechanicsTest/test-failures.txt` file (up to 25 failures) so CI can surface failure reasons without opening the full server log. - Token hygiene: do **not** open/read `build/integration-test-logs/*.log` unless the user explicitly asks for log inspection; rely on the compact console summary by default and ask for permission before digging into full logs. - PacketEvents is shaded into the plugin; integration tests do not inject external packet libraries. - `relocateIntegrationTestClasses` (ShadowJar) relocates PacketEvents references in test classes only. - `integrationTestJar` is a plain `Jar` task that embeds the relocated test classes plus runtime deps, excluding PacketEvents so the test plugin resolves PacketEvents from the main plugin’s shaded copy. - `PacketCancellationIntegrationTest` now uses a cancellable `CompletableFuture.await()` so `withTimeout` actually aborts when no packet arrives. - `PacketCancellationIntegrationTest` now drives PacketEvents via `PacketEventsImplHelper.handleClientBoundPacket` with a synthetic `User` instead of relying on live channel injection; this avoids timeouts when PacketEvents does not emit send events for fake channels. - `PacketCancellationIntegrationTest` sets the Bukkit player on the synthetic PacketEvents event so module listeners can match `PacketSendEvent#getPlayer`. - Matrix task: `integrationTest` depends on `integrationTestMatrix` which runs per-version tasks like: - `integrationTest1_19_2`, `integrationTest1_21_11`, `integrationTest1_12`, `integrationTest1_9` - Test result handoff: - `OCMTestMain` writes `plugins/OldCombatMechanicsTest/test-results.txt` containing `PASS` or `FAIL`. - `KotestRunner` also writes `plugins/OldCombatMechanicsTest/test-failures.txt` (small failure summary). - Gradle `checkTestResults` fails build if file missing, or content is not `PASS`. ## Version matrix + Java selection - Config is in `build.gradle.kts`: - `integrationTestVersions` from property or defaults. - `requiredJavaVersion` selects Java based on version. - Pre-1.13 versions use `integrationTestJavaVersionLegacyPre13` (default 8). - Modern versions use Java 25 if `>=1.20.5` else Java 17. - Legacy vanilla jar cache: - `downloadVanilla` task downloads Mojang server jars for <=1.12 and writes `run//cache/mojang_.jar`. ## Kotlin test runner split (Java 11+ vs Java 8) - Kotest 6 (Java 11+) is used for 1.19.2 and 1.21.11. - Kotest runner class: `kernitus.plugin.OldCombatMechanics.KotestRunner` - Project config: `KotestProjectConfig` - Java 8 uses a separate runner: - `kernitus.plugin.OldCombatMechanics.LegacyTestRunner` - Currently a **smoke test** only (verifies plugin enabled + `WeaponDamages` loaded). - This is a placeholder and **not a full integration test**. ## Fake player implementation notes - Primary fake player implementation is `src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/FakePlayer.kt`. - It relies on `xyz.jpenilla:reflection-remapper` to map modern NMS names. - On legacy servers (1.12), reflection remapper mappings are unavailable; code falls back to `ReflectionRemapper.noop()`. - As-is, `FakePlayer` uses modern NMS class names (`net.minecraft.server.MinecraftServer`, etc.). - This fails on 1.12 which uses versioned NMS (`net.minecraft.server.v1_12_R1.*`). - 1.12 requires a dedicated fake player path or version-aware class mapping. ## Java 8 compatibility work - Java 8 compatibility backports already done in main code (records/pattern matching removed). - Java 8-incompatible APIs replaced: - `Stream.toList()` -> `collect(Collectors.toList())` - `Set.of`/`List.of` -> `Collections.unmodifiableSet(new HashSet<>(Arrays.asList(...)))` etc. - Added missing import in `PotionTypeCompat` for `PotionData`. - Build config sets `options.release.set(8)` for Java, Kotlin `jvmTarget = 1.8`. ## Dependency / build updates - Kotlin: 2.3.0 - Kotest: 6.0.7 - run-paper plugin: 3.0.2 - Hangar publish plugin: 0.1.4 - Other deps updated (bstats, netty, BSON, XSeries, authlib, reflection-remapper, adventure). - PacketEvents is now used for packet interception (shaded and relocated in the main jar). - PacketEvents dependency moved to `2.11.2-SNAPSHOT` (CodeMC snapshots) for 1.21.11 support. - JSR-305 added for `javax.annotation.Nullable` (compileOnly). ## Current failing area - Paper 1.12 integration tests **do not run real fake player tests yet**. - Desired fix: add proper 1.12 fake player implementation (e.g., version-specific NMS path like `v1_12_R1`). - Example 1.12 fake player implementation provided by user (NMS, PlayerList manipulation, packet send, etc.). - We should integrate a conditional path in `FakePlayer` for 1.12 using versioned NMS classes or an alternate helper. ## Local test commands - Run full matrix: - `./gradlew integrationTest` - Change matrix: - `./gradlew integrationTest -PintegrationTestVersions=1.19.2,1.21.11,1.12` - Set Java toolchain paths (example): - `ORG_GRADLE_JAVA_INSTALLATIONS_PATHS=/path/to/jdk8:/path/to/jdk17:/path/to/jdk25 ./gradlew integrationTest` ## Notes - Removed the dead reflection utility `ClassType` and the unused `Reflector#getClass(ClassType, String)` overload; `Reflector#getClass(String)` remains the supported class-resolution helper. - `SpigotFunctionChooser` now only falls back for compatibility-style failures (LinkageError family, missing-method/class reflection failures, and explicit compatibility-signalled `UnsupportedOperationException` via `compat`/`compatibility` markers), and rethrows ordinary runtime logic failures instead of silently selecting fallback (for example generic "incompatible" wording does not trigger fallback). - `AttackCompat` now only treats Bukkit `Player#attack` as success when it yields an observable living-target hit (health/lastDamage/noDamageTicks signal); otherwise it falls back to NMS attack candidates. - `AttackCompat` now treats boolean-return NMS attack methods that return `false` as failed attempts and continues trying other candidates, with expanded failure diagnostics including false-result and exception counts. - Entity-click dedupe in `ModuleSwordBlocking` now uses a taskless lazy-prune timestamp map (`System.nanoTime`) instead of a one-tick scheduled set clear, with a short dedupe window and periodic/size-triggered expiry pruning. - `ModuleSwordBlocking` now handles `PlayerInteractEntityEvent` and `PlayerInteractAtEntityEvent` for main-hand sword blocking, with short time-window dedupe to prevent duplicate side effects when both events fire for the same click. - Removed the unused main-source Java tester package (`kernitus.plugin.OldCombatMechanics.tester`), deleted stale commented test-command code from `OCMCommandHandler`, and dropped the now-obsolete Gradle source-set exclusion for that package. - Paper 1.12 sometimes fails to download legacy vanilla jar from old Mojang endpoint. The custom `downloadVanilla` task fixes that by using the v2 manifest. - 1.21.11 servers log hostname warnings and Unsafe warnings; tests still pass. - 1.9 integration tests are currently on hold per user request. - Kotest filters (`kotest.filter.specs`, `kotest.filter.tests`) are now passed through Gradle into the run-paper JVM args for integration tests. - Reflection should be used only as a fallback (performance cost); prefer direct API/code paths when available. - The Hangar publish workflow exports `HANGAR_API_TOKEN` to match the Gradle Hangar publish configuration. - `ModuleFishingRodVelocity` uses a single shared per-tick task (1.14+) to adjust hook gravity for all active hooks, instead of one scheduled task per hook. - `AttackCooldownTracker#getLastCooldown` is safe to call when the tracker is not registered (returns null) and uses a `HashMap` rather than a `WeakHashMap`. - `AttackCooldownTracker` defensively feature-detects `HumanEntity#getAttackCooldown` and avoids scheduling its per-tick sampler when the API exists (modern/backported servers). - `ModulePlayerKnockback` uses a `HashMap` + a single shared 1-tick expiry cleaner for pending velocity overrides, instead of `WeakHashMap` + one scheduled task per hit. - `ModuleShieldDamageReduction` uses a `HashMap` + a single shared 1-tick expiry cleaner for the “fully blocked” armour-durability suppression, instead of `WeakHashMap` + one scheduled task per hit. - `ModuleOldArmourDurability` uses a `HashMap` + a single shared 1-tick expiry cleaner for the “explosion damaged armour” suppression, instead of `WeakHashMap` + one scheduled task per explosion. - `ModulePlayerRegen` uses tick-based interval tracking (1.8-like; TPS aware) with a `HashMap` and a single shared tick counter task that runs only while players are tracked. - `ModuleDisableEnderpearlCooldown` uses a `HashMap` and lazily drops expired cooldown entries during checks (wall-clock cooldown; no recurring task). - `ModuleSwordBlocking` no longer version-gates Paper support; it feature-detects Paper data component APIs and avoids ConcurrentModificationException by iterating legacy tick state over a snapshot. - Do not gate behaviour on hard-coded Minecraft version numbers; use feature detection (class/method presence) because some servers backport APIs. - Weapon/armour unknown-enchantment warnings only fire for non-`minecraft` namespaces; legacy servers fall back to a known vanilla-enchantment list to avoid warning on built-ins. - For NMS access, prefer the project Reflector helpers (`utilities.reflection.Reflector`) over ad-hoc reflection, and avoid hard-coded versioned class names where heuristics (signatures/fields) can locate methods safely. - Added integration tests in `OldPotionEffectsIntegrationTest` for strength addend scaling (Strength II and III), a distinct modifier value check, and strength multiplier scaling. - Added integration test ensuring vanilla strength addend applies when `old-potion-effects` is disabled. - Strength modifier in `OCMEntityDamageByEntityEvent` now stores per-level value (3) and applies level when reconstructing base damage. - Added `OldToolDamageMobIntegrationTest` to assert old-tool-damage config affects vindicator iron-axe hits. - `KotestRunner` class list updated to include `OldToolDamageMobIntegrationTest`. - `ModuleOldToolDamage` now adjusts mob weapon damage by shifting base damage with the configured-vs-vanilla delta for non-player damagers. - `ModuleOldToolDamage` documents that mob custom weapons are not detected; the delta is always applied for mobs and may conflict with other plugins. - Added `WeaponDurabilityIntegrationTest` covering tool durability vs hit counts during invulnerability and after it expires (FakePlayer attacker vs FakePlayer victim); registered in `KotestRunner`. - `WeaponDurabilityIntegrationTest` writes debug summaries to `build/weapon-durability-debug-.txt`. - `WeaponDurabilityIntegrationTest` and `OldToolDamageMobIntegrationTest` now resolve debug output paths relative to the repo root (based on the server run directory), avoiding hard-coded home paths. - `OldToolDamageMobIntegrationTest` uses a Villager victim and waits for a real Vindicator hit by setting a target and retrying with tick delays (plus a best-effort NMS attackCompat call) before asserting the mob tool-damage delta. - Module assignment is strict for configurable modules: every non-internal module must appear in exactly one of `always_enabled_modules`, `disabled_modules`, or a modeset. Internal modules (`modeset-listener`, `attack-cooldown-tracker`, `entity-damage-listener`) are always enabled and must not be listed; reload/enable fails if they are configured. - Use British English spelling and phraseology at all times. - DO NOT use American English spelling or phraseology under any circumstances. - Never hard-code absolute filesystem paths in tests or production code; resolve locations relative to the repo root or server run directory. - Added `DisableOffhandIntegrationTest` to assert the disable-offhand modeset-change handler does not clear the offhand when the module is not enabled for the player. - `KotestRunner` now includes `DisableOffhandIntegrationTest` in its explicit class list. - When adding new integration test specs, add them to the explicit `.withClasses(...)` list in `KotestRunner` because autoscan is disabled. - Added `ToolDamageTooltipIntegrationTest` (in `KotestRunner` list) to define behaviour for an opt-in “configured tool damage tooltip” feature (lore line) under `old-tool-damage.tooltip` (`enabled`, `prefix`). - `old-tool-damage.tooltip.enabled` is now enabled by default in the bundled config so players can see the configured damage in-game. - Modules are enabled/disabled solely via `always_enabled_modules`, `disabled_modules`, and `modesets` (no per-module `enabled:` toggle). - `SwordBlockingIntegrationTest` uses synthetic `PlayerInteractEvent` right-clicks; on legacy (offhand-shield) path this cannot reliably assert `isBlocking`/`isHandRaised` (client-driven), so tests treat “blocking applied” as either a shield injection or a raised hand depending on path. - Added `PacketCancellationIntegrationTest` to cover PacketEvents sweep-particle and attack-sound cancellation using PacketEvents wrappers/listeners (registered in `KotestRunner`). - Added `ModesetRulesIntegrationTest` to cover always-enabled, disabled, and modeset-scoped module rules plus reload failures for invalid assignments. - Added `ConfigMigrationIntegrationTest` to cover config upgrade migration into always/disabled module lists and preservation of custom modesets. - Added a `weakness should not store negative last damage values` test in `InvulnerabilityDamageIntegrationTest` that forces `old-potion-effects.weakness.modifier = -10`, consumes a weakness potion (amplifier -1), attacks once, and asserts the stored last damage is non-negative; passes on 1.12/1.19.2 after clamping, but 1.21.11 can still fail with `No stored last damage for victim (events=0)` (attack event not recorded). - `EntityDamageByEntityListener.checkOverdamage` now clamps the stored `lastDamages` value to a minimum of 0 to avoid negative last-damage entries when weakness (or other modifiers) drives pre-clamp damage below zero. - Weakness amplifier clamping changed in 1.20+: attempts to use amplifier `-1` are clamped to `0` (Weakness I). With low-damage weapons this can yield zero vanilla damage, and Paper 1.21 does not fire `EntityDamageByEntityEvent` for zero damage, so tests that rely on an EDBE hit must use a stronger weapon or account for the clamp. - `OldPotionEffectsIntegrationTest` now disables the module by moving `old-potion-effects` into `disabled_modules` (and removing it from modesets/always lists), then uses `Config.reload()`; the `withConfig` helper restores module lists/modesets and saves+reloads config to keep state consistent. - `FireAspectOverdamageIntegrationTest` includes afterburn-vs-environmental fire-tick checks for both player and zombie victims, with and without Protection IV armour (mirrors issue 707 MRE). - Release workflow (`.github/workflows/build-upload-release.yml`) now uploads Bukkit files via `itsmeow/curseforge-upload@v3` against the `minecraft` endpoint, reusing `DBO_UPLOAD_API_TOKEN`, and prefixes `GAME_VERSIONS` as `1:` so CurseForge selects the Bukkit-compatible type-1 version entries. ## Test harness shortcuts (known non-realistic paths) - Several integration tests manually construct and fire Bukkit events rather than triggering real in-world actions: - `GoldenAppleIntegrationTest` (manual `PlayerItemConsumeEvent` and `PrepareItemCraftEvent`) - `OldPotionEffectsIntegrationTest` (manual `PlayerItemConsumeEvent`, `PlayerInteractEvent`, `BlockDispenseEvent`) - `OldArmourDurabilityIntegrationTest` (manual `PlayerItemDamageEvent`, `EntityDamageEvent`) - `PlayerKnockbackIntegrationTest` (manual `EntityDamageByEntityEvent`, `PlayerVelocityEvent`) - `SwordBlockingIntegrationTest` (manual `PlayerInteractEvent`) - `SwordSweepIntegrationTest` (manual `EntityDamageByEntityEvent`) - Some tests directly invoke module handlers instead of going through the event bus: - `PlayerKnockbackIntegrationTest` (direct `module.onEntityDamageEntity`) - `SwordSweepIntegrationTest` (direct `module.onEntityDamaged`) - `AttributeModifierCompat` synthesises a fallback attack-damage modifier from `NewWeaponDamage` when API attributes are missing. - Fake player implementations use simulated login/network plumbing (EmbeddedChannel + manual login/join/quit events), not a real networked client. - FakePlayer uses a plain `EmbeddedChannel` (not an anonymous subclass) so PacketEvents treats it as fake and does not disallow login; dummy `decoder`/`encoder` handlers are still added to the pipeline. - FakePlayer now schedules a manual NMS tick for non-legacy servers (prefers `doTick`, then `tick`, falls back to `baseTick`) to drive vanilla ticking like fire and passive effects. - FakePlayer tick shim invokes `baseTick` whenever `remainingFireTicks > 0` (burning) to ensure fire tick damage events still occur on Paper 1.21+ (which can short-circuit `doTick`/`tick` for fake players). When the fake player is in water, it prefers `doTick`/`tick` so the server can properly clear fire ticks (extinguish) before any fire damage is applied. - FakePlayer now prefers `PlayerList.placeNewPlayer` over the legacy `load`/manual list insertion path to better mirror vanilla login initialisation (helps player fire-tick damage on modern servers). - FakePlayer does not emulate fire-tick damage; fire ticks should be driven by the NMS tick path. - FakePlayer now forces a world add when the Bukkit world does not report the fake player entity after `placeNewPlayer` to keep PvP interactions reliable. - FakePlayer now clears invulnerability/instabuild abilities after spawn (plus a legacy fallback) to improve PvP interactions between fake players. - EntityDamageByEntityListener now logs extra debug about lastDamage restoration for non-entity damage, and documents the vanilla 1.12 damage flow in checkOverdamage. - EntityDamageByEntityListener no longer overwrites the stored last-damage baseline when cancelling “fake overdamage” (e.g. cancelled fire tick during invulnerability), preventing subsequent hits from incorrectly bypassing immunity. - Stored last-damage baselines now use a single lightweight expiry sweeper (tick-based TTL) instead of scheduling one Bukkit task per damage event; this keeps the hot path allocation-free. Expiry is monotonic (only extended, never shortened) and has a small minimum TTL to tolerate `maximumNoDamageTicks = 0`. - `WeaponDurabilityIntegrationTest` now uses a Zombie victim (fake-player attacker) and prefers the Bukkit `Player#attack` API before falling back to reflective NMS attack resolution, to make hit delivery reliable on modern servers. - `ModuleSwordSweepParticles` and `ModuleAttackSounds` now use PacketEvents listeners/wrappers instead of ProtocolLib. - `PacketCancellationIntegrationTest` now builds a `PacketSendEvent` directly (reflection) from the transformed buffer, sets the packet id/type explicitly, and dispatches it via the PacketEvents `eventManager` so module listeners can cancel reliably. - README now includes a licence note: source remains MPL‑2.0, but pre-built jars bundling PacketEvents are distributed under GPLv3; builds without PacketEvents can remain MPL‑2.0. - Legacy fake player (1.9) now uses a plain `EmbeddedChannel` with dummy `decoder`/`encoder` handlers, mirroring the modern fake player setup so PacketEvents treats it as fake. - `ModuleChorusFruit` now reimplements the chorus teleport search (16 attempts, world-border aware, passable feet/head, solid ground) for custom teleport distances; falls back to vanilla target if no safe spot found. - Added `ChorusFruitIntegrationTest` (in KotestRunner list) to assert custom chorus teleport distance lands on a safe block within the configured radius. - Chorus fruit safety test now handles legacy 1.12 by using solid/non-solid checks when `Block#isPassable` is absent; passes on 1.12, 1.19.2, and 1.21.11. - `ModuleOldToolDamage` now supports configurable TRIDENT (melee), TRIDENT_THROWN, and MACE damage; mace preserves its vanilla fall bonus while overriding base damage. New defaults added to `old-tool-damage.damages`. - Added `ModuleAttackRange` (Paper 1.21.11+ only) to apply a configurable attack_range data component (default 1.8-like: 0–3 range, creative 0–4, margin 0.1, mob factor 1.0); auto-disables on Spigot/older versions. `attack-range` module listed in `disabled_modules` by default. - `ModuleSwordBlocking` now only strips the Paper `CONSUMABLE` component from sword items, preventing food and other consumables from inheriting a `!minecraft:consumable` patch when inventory events fire on 1.20.5+. - Added `DisableOffhandReflectionIntegrationTest` (in `KotestRunner` list) to ensure reflective access to `InventoryView#getBottomInventory`/`getTopInventory` works on non-public CraftBukkit view implementations. - `Reflector.getMethod` overloads now include declared methods and call `setAccessible(true)` to avoid `IllegalAccessException` when CraftBukkit uses non-public view classes (e.g. `CraftContainer$1` on 1.20.1). - Added `AttackRangeIntegrationTest` (1.21.11+) to assert vanilla hits at ~3.6 blocks and 1.8-style attack_range reduces reach so the same hit misses; registered in `KotestRunner`. - Removed the cancelled S3-only `AttackRangeIntegrationTest` case `swap hand keeps attack-range off offhand sword (Paper 1.21.11+)` so ongoing S6 validation is not blocked by a parked slice artefact. - InvulnerabilityDamageIntegrationTest adds a case asserting environmental damage above the baseline applies during invulnerability (manual EntityDamageEvent). - `gradle.properties` gameVersions list now includes 1.21.11 down to 1.21.1 (plus 1.21) ahead of existing entries. - GitHub release asset now keeps a stable filename `OldCombatMechanics.jar` (no version suffix); the CurseForge upload uses the same path. - Expanded `SwordBlockingIntegrationTest` to cover right-click blocking, non-sword handling, offhand restoration (hotbar change and drop cancel), permission gating, and preserving an existing real shield. - Added `PaperSwordBlockingDamageReductionIntegrationTest` (in KotestRunner list) to regression-test that Paper sword blocking is recognised server-side (via `ModuleSwordBlocking.isPaperSwordBlocking`) and produces a non-zero 1.8-style reduction from `applyPaperBlockingReduction`. This uses a synthetic damage event to avoid flakiness from mob AI / PvP settings. - Paper-only sword blocking uses a runtime-gated helper (`kernitus.plugin.OldCombatMechanics.paper.PaperSwordBlocking`) that applies consumable + blocking components via cached reflection (lookup once, MethodHandle invoke thereafter). 1.8-style reduction is applied via `EntityDamageByEntityListener` using the `BLOCKING` damage modifier, while legacy/non-Paper keeps the shield swap path. - Fixed legacy (1.9.x) sweep detection flakiness by tracking priming per-attacker UUID (not `Location`, which is unstable due to yaw/pitch) and clearing the set on module reload; stabilises `SwordSweepIntegrationTest` on 1.9.4. - `ModuleSwordSweep` now uses a one-shot next-tick clear (single scheduled task guarded by `pendingClearTask`) instead of a repeating every-tick task, to avoid doing any work on ticks where no sword hits occurred. - `ModuleSwordBlocking` legacy (offhand shield) path no longer schedules per-player repeating tasks; it now uses a single shared tick runner with per-player tick deadlines (10-tick warmup + 2-tick poll + restoreDelay), which reduces task churn under heavy right-click spam. - `ModuleLoader` now clears the static module list on initialise to prevent duplicate registrations after hot reloads. - Added `ConsumableComponentIntegrationTest` coverage to assert the Paper sword-blocking consumable cleaner leaves swords untouched when the module is disabled (modeset/world) and does not mutate swords when no component change is required. - `ConsumableComponentIntegrationTest` now seeds and asserts the CONSUMABLE component via NMS reflection (not Paper API) and uses standalone CraftItemStacks for cursor/current items to avoid classloader mismatches and fake-player cursor side effects. - `ModuleSwordBlocking#onModesetChange` now strips the Paper CONSUMABLE component from the player’s main hand/offhand and stored swords when sword-blocking is disabled for that player, preventing component “taint” lingering after mode changes. - `ModuleSwordBlocking#reload` now strips Paper sword-blocking consumable components from online players when the module is disabled globally (disabled_modules) to avoid lingering taint after config reloads. - `ModuleSwordBlocking` now gates the Paper consumable animation by PacketEvents client version (>=1.20.5); older clients fall back to the offhand shield and unknown versions default to the animation path. - `config.yml` now documents that Paper 1.20.5+ uses the consumable-based sword-blocking animation, with older/Paperless servers falling back to an offhand shield. - `config.yml` now notes that ViaVersion clients older than 1.20.5 also fall back to the shield behaviour. - Added `ConsumableComponentIntegrationTest` coverage for disabling sword-blocking via `disabled_modules` and asserting the consumable component is cleared after config reload. - Extended `ConsumableComponentIntegrationTest` to cover disabled-module right-click suppression, reload toggling, stored-inventory cleanup, offhand stability, and modeset-change behaviour after a disabled reload. - Added `ConsumableComponentIntegrationTest` coverage for forcing an older client version and asserting sword-blocking falls back to an offhand shield without applying consumable components. - `ConsumableComponentIntegrationTest` now uses PacketEvents reflection to seed a User/client version for fake players when PacketEvents has not registered one yet. - `ModuleSwordBlocking#restore` no longer skips offhand restoration just because Paper support is present; older clients using the shield fallback now restore their original offhand item correctly. - Added `ConsumableComponentIntegrationTest` coverage asserting the older-client shield fallback restores the offhand item on hotbar change. - Added `ConsumableComponentIntegrationTest` coverage for inventory-glitch regressions: unknown PacketEvents client versions should use shield fallback, middle-clicking custom GUIs should not mutate held sword components, and custom-GUI drag events should not rewrite top-inventory swords. - Those inventory-glitch regressions now pass on 1.21.11 after the unknown-client fallback + click/drag scope fixes. - `ModuleSwordBlocking#supportsPaperAnimation` now treats unknown PacketEvents client versions as shield-fallback only when a PacketEvents `User` exists; if no user is registered yet (early login/synthetic test player), it keeps animation support to avoid regressing normal modern-client behaviour. - `ModuleSwordBlocking.ConsumableCleaner#onInventoryClickPost` now re-applies the main-hand consumable component only for click paths that can actually affect the selected hotbar slot (selected NUMBER_KEY swaps or direct selected-slot player-inventory clicks), and ignores middle-clicks. - `ModuleSwordBlocking.ConsumableCleaner#onInventoryDrag` now ignores top-inventory raw slots and skips main-hand re-application when the drag only touched top inventory slots, preventing custom-GUI slot rewrites. - Added `ConsumableComponentIntegrationTest` coverage for legacy fallback shield-guard scope: custom GUI shield-icon clicks and unrelated shield drops should not be cancelled while fallback is active; temporary offhand shield swap blocking should remain enforced. - `ModuleSwordBlocking#onInventoryClick` legacy shield-guard scope now only cancels direct offhand temporary-shield interactions (player inventory slot 40), avoiding cancellation of unrelated custom-GUI shield clicks. - `ModuleSwordBlocking#onInventoryClick` also blocks `ClickType.SWAP_OFFHAND` while temporary legacy shield state is active, preventing offhand shield extraction via inventory swap-clicks. - `ModuleSwordBlocking#onItemDrop` no longer cancels shield drops while legacy fallback state is active; it now force-restores the temporary shield state immediately to avoid trapping unrelated shield drops. - `ModuleSwordBlocking#isPlayerBlocking` now requires an actual offhand shield before treating `isBlocking`/`isHandRaised` as legacy shield-blocking, preventing stale hand-use state from suppressing fallback shield injection. - `ModuleSwordBlocking#supportsPaperAnimation` now falls back to `User#getClientVersion` when `PlayerManager#getClientVersion` is null, improving old-client fallback stability in synthetic/integration scenarios. - `ModuleSwordBlocking#supportsPaperAnimation` now fails safe to legacy shield fallback when PacketEvents client-version resolution is unavailable (resolver initialisation missing, resolver methods/objects null, or reflection errors), while preserving existing behaviour for normal early-login/synthetic-player cases. - `ModuleSwordBlocking#onPlayerSwapHandItems` now treats stale legacy stored-shield state as non-authoritative for Paper-animation players: it clears stale legacy entries instead of cancelling swaps, so synthetic swap listeners still run. - `ModuleSwordBlocking#onPlayerSwapHandItems` now restores any stale legacy stored offhand item (via `restore(..., true)`) before clearing legacy state on the Paper-animation path, so stale entries are not silently discarded. - `ConsumableCleaner#onSwap` now snapshots the held hotbar slot and only reapplies the Paper consumable component when the slot is unchanged on the deferred tick; offhand stripping remains deferred as before. - The new legacy-scope regressions now pass on 1.19.2 and 1.21.11. - `ModuleSwordBlocking.ConsumableCleaner#onInventoryClickPost` now snapshots click context (held slot and open inventory top/bottom) and skips next-tick reapply when that context is stale, preventing deferred reapply from tainting a newly selected main-hand sword. - Added `ConsumableComponentIntegrationTest` coverage for stale `PlayerSwapHandItemsEvent` deferred reapply: if held slot changes before next tick, the newly selected main-hand sword must not gain a consumable component, while swapped-offhand sword cleanup still occurs. - Added `ConsumableComponentIntegrationTest` regression coverage for stale `PlayerSwapHandItemsEvent` deferred reapply when the open inventory view changes before next tick: the new main-hand context must not be tainted, while swapped-offhand consumable cleanup must still run. - `ModuleSwordBlocking.ConsumableCleaner#onSwap` now snapshots open-inventory top/bottom identity at swap time and requires a view match only for deferred main-hand reapply; deferred offhand consumable cleanup still runs even when the view changed. - `ModuleSwordBlocking.ConsumableCleaner` click/drag handlers now follow a minimal-mutation policy (no proactive consumable strip/apply in `InventoryClickEvent` or `InventoryDragEvent` paths); cleanup is handled opportunistically via lifecycle/transition handlers (`onModesetChange`/`reload`/world-change, held-slot, and swap paths) using a shared per-player consumable sweep helper. - `ModuleSwordBlocking#onModesetChange` now force-restores stale legacy fallback shield state (`restore(..., true)`) when sword-blocking becomes disabled for a player, before sweeping Paper consumable components. - `ModuleSwordBlocking.ConsumableCleaner#onWorldChange` now strips consumable components from main hand, offhand, and stored swords without re-applying, so world changes clear stale consumable state consistently. - `ModuleSwordBlocking.ConsumableCleaner#onQuit` now uses the same strip-only full sweep as world-change cleanup (main hand, offhand, and stored swords), ensuring logout clears stale consumable state from storage as well. - `ModuleSwordBlocking` now handles `PlayerJoinEvent` with a force legacy restore (`restore(..., true)`) followed by strip-only consumable cleanup (main hand, offhand, and stored swords), so join clears stale state without re-applying consumable components. - `ModuleSwordBlocking` inner listener `ConsumableCleaner` was renamed to `ConsumableLifecycleHandler` (registration updated; behaviour unchanged). - Added `sword-blocking.paper-animation` config (default `true`) to hard-disable the Paper consumable animation path; when false, sword-blocking always uses the legacy shield fallback and reload/lifecycle cleanup strips stale consumable state without re-applying it. - Legacy sword-blocking now marks injected temporary offhand shields when marker APIs are available so death handling can identify the temporary drop path reliably. - `ModuleSwordBlocking#onPlayerDeath` now pops stored offhand exactly once, clears legacy state deterministically, respects `keepInventory` without rewriting drops, rewrites at most one temporary shield drop, and adds the stored offhand drop when no temporary shield drop is found. - Legacy shield-drop reconciliation now uses a strict safety-first fallback when marker APIs are unavailable: it does not guess temporary shields from plain shield shape, avoiding accidental replacement of legitimate shields (stored offhand is appended instead). - For synthetic/manual death events where drop metadata may not preserve the temporary-shield marker, `ModuleSwordBlocking#onPlayerDeath` allows a single shield-drop rewrite only when the player offhand was verified as marker-tagged at death time. - `ModuleAttackCooldown` now supports `disable-attack-cooldown.held-item-attack-speeds.` overrides with XMaterial/Material matching, falls back to `generic-attack-speed`, reconciles on join/world/modeset/hotbar/swap, restores vanilla base ATTACK_SPEED 4.0 when disabled, and no longer calls `player.saveData()` on attack-speed updates. The bundled config defaults keep most items on the no-cooldown fallback, with `TRIDENT`, `MACE`, and spear variants listed as the built-in slower exceptions; keys for newer-version materials are ignored safely on older servers. - `ModuleAttackCooldown` hotbar/swap handling is immediate best-effort only: at `EventPriority.HIGHEST`, it re-reads the live inventory only when the event is already cancelled, otherwise it trusts the event payload and applies straight away; later plugin mutations may win until the next ordinary reconcile trigger. - `.github/CONTRIBUTING.md` now states that contributions should include automated coverage within the existing test framework where practical, and that new classes should be written in Kotlin by default. ## Fire aspect / fire tick test notes - `FireAspectOverdamageIntegrationTest` now uses a Zombie victim for real fire tick sampling, with max health boosted (via MAX_HEALTH attribute) to survive rapid clicking. - The first two tests fire a synthetic `EntityDamageEvent` with `FIRE_TICK` to control timing and make the baseline check deterministic. - Paper 1.12 applies attack-cooldown scaling before the Bukkit damage event fires; fake players can start with a low initial cooldown, producing a weak first hit and allowing a stronger second hit as legitimate “overdamage”. `FireAspectOverdamageIntegrationTest` now waits a few ticks before the first attack to make the first hit stable on 1.12. - Added extra fire edge-case coverage in `FireAspectOverdamageIntegrationTest`: fire resistance + fire-immune victim rapid-click parity, water extinguish behaviour (no fire tick damage while submerged), fire protection vs protection comparisons (uses a Zombie victim for consistency), and alternating attackers during invulnerability. - Legacy (1.12) fake player behaviour differs for player-specific fire tick sampling, so the player afterburn-vs-environmental comparisons are no-ops on legacy; the Zombie variants still run across all versions. ## TDAID reminders (this repo) - Plan → Red → Green → Refactor → Validate. - Red phase: only touch tests. Do not modify production code. - Green phase: only touch production code. Do not modify tests. - Refactor phase: cleanups only; keep behavior unchanged and tests green. - Validate phase: rerun tests and do a human sanity check before declaring done. ================================================ FILE: CHANGELOG.md ================================================ # Changelog ## [2.4.0](https://github.com/kernitus/BukkitOldCombatMechanics/compare/v2.3.0...v2.4.0) (2026-03-08) ### Features * togglable paper sword blocking ([5d3887d](https://github.com/kernitus/BukkitOldCombatMechanics/commit/5d3887d5b18849ec150cabbd459e66104708dda3)) ### Bug Fixes * don't overwrite swords on every click [#843](https://github.com/kernitus/BukkitOldCombatMechanics/issues/843) ([4323853](https://github.com/kernitus/BukkitOldCombatMechanics/commit/432385320c418c0e46df6869e56af051629bfdab)) * **inventory:** harden stale deferred item mutation paths ([a92664d](https://github.com/kernitus/BukkitOldCombatMechanics/commit/a92664d293af0dd5fd445ca7db47e078386affd7)) * **reflection:** tighten chooser compatibility fallback ([f383340](https://github.com/kernitus/BukkitOldCombatMechanics/commit/f3833406e4b471a3d89f5e1c5ed8ada9d1d3e1ae)) * strip sword consumable component ([4624ac0](https://github.com/kernitus/BukkitOldCombatMechanics/commit/4624ac0c422d7f05835cd511b701026769917292)) * **sword-blocking:** clear sword consumable components on reload when disabled ([b887a28](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b887a28a95b07efa5ec641660aee590207a0d50d)), closes [#845](https://github.com/kernitus/BukkitOldCombatMechanics/issues/845) * **sword-blocking:** fall back to shield for pre-1.20.5 clients ([388bee5](https://github.com/kernitus/BukkitOldCombatMechanics/commit/388bee573169a45a27c41558a946e493880677e7)), closes [#842](https://github.com/kernitus/BukkitOldCombatMechanics/issues/842) * **sword-blocking:** harden inventory fail-safes to prevent ghosting ([8889bfe](https://github.com/kernitus/BukkitOldCombatMechanics/commit/8889bfeb467c9f64f4d35a2d35e8456f179c35d1)) * **sword-blocking:** harden legacy death shield drop reconciliation ([2bb730e](https://github.com/kernitus/BukkitOldCombatMechanics/commit/2bb730e5c223da5c1cd73c91a093c86d3dedefbb)) * **sword-blocking:** prevent GUI click/drag item rewrites & fallback unknown clients to shield ([cfc596c](https://github.com/kernitus/BukkitOldCombatMechanics/commit/cfc596c3d674fd99a9c07b4c7c07c354d58fc755)) * **sword-blocking:** prevent legacy fallback from cancelling unrelated shield interactions ([727fa97](https://github.com/kernitus/BukkitOldCombatMechanics/commit/727fa97b4e904ac06514170aae27ba1bc91dbb8b)) * **sword-blocking:** restore offhand item for pre-1.20.5 fallback clients ([68073e8](https://github.com/kernitus/BukkitOldCombatMechanics/commit/68073e876dffa853329c414d156086fe1c76b3fd)) * **sword-blocking:** sweep stale consumable state on join/quit/world ([96d6981](https://github.com/kernitus/BukkitOldCombatMechanics/commit/96d698145e9d8f1543b272adf87d5026076de927)) ## [2.3.0](https://github.com/kernitus/BukkitOldCombatMechanics/compare/v2.2.0...v2.3.0) (2026-01-24) ### Features * 1.8 hitbox ([5cbd93d](https://github.com/kernitus/BukkitOldCombatMechanics/commit/5cbd93d89dde101dd7e750d4ee13e733b6dfd4a2)), closes [#69](https://github.com/kernitus/BukkitOldCombatMechanics/issues/69) * always & disabled modules lists ([5f7bf12](https://github.com/kernitus/BukkitOldCombatMechanics/commit/5f7bf127412e2675294d27703ac6562a4c8e0c9d)) * always & disabled modules lists ([18dd6e1](https://github.com/kernitus/BukkitOldCombatMechanics/commit/18dd6e17aeb5e391fbb5704c0726d05e0b676971)) * copper tools support [#822](https://github.com/kernitus/BukkitOldCombatMechanics/issues/822) [#823](https://github.com/kernitus/BukkitOldCombatMechanics/issues/823) ([47ffa96](https://github.com/kernitus/BukkitOldCombatMechanics/commit/47ffa963ecc8619f064b98054d35df81f89a682d)) * custom trident & mace damage ([be70c5b](https://github.com/kernitus/BukkitOldCombatMechanics/commit/be70c5bb7756699fe4e3cb5bced450df3308f195)), closes [#757](https://github.com/kernitus/BukkitOldCombatMechanics/issues/757) * item damage lore ([0ca855a](https://github.com/kernitus/BukkitOldCombatMechanics/commit/0ca855a21634c933ab0626770a74f756e57849fe)), closes [#775](https://github.com/kernitus/BukkitOldCombatMechanics/issues/775) * kotlin integration tests ([c63c940](https://github.com/kernitus/BukkitOldCombatMechanics/commit/c63c940fcc292d4db3a27185a613a01e7c5c04f0)) * switch from protocollib to packetevents ([44afce1](https://github.com/kernitus/BukkitOldCombatMechanics/commit/44afce1a0f01a0ad54b39662e3597a8e371c5454)), closes [#790](https://github.com/kernitus/BukkitOldCombatMechanics/issues/790) * sword blocking animation [#769](https://github.com/kernitus/BukkitOldCombatMechanics/issues/769) ([8596c9d](https://github.com/kernitus/BukkitOldCombatMechanics/commit/8596c9da58dc2167d05ac878d4a7809014ff02d8)) * warn on unknown effects, enchants, etc ([fa828d3](https://github.com/kernitus/BukkitOldCombatMechanics/commit/fa828d3469ca18b51ffd0871bd8e510f0c831d1c)) ### Bug Fixes * 'disable-offhand' module working even if disabled ([ecca0b5](https://github.com/kernitus/BukkitOldCombatMechanics/commit/ecca0b56d6f8c1d9b2e96d190ae2098dfeb10fc4)) * `disable-offhand` handling on modeset change ([54aaf0c](https://github.com/kernitus/BukkitOldCombatMechanics/commit/54aaf0c1a0a812c89c39ae0c49fe6300760a8ecc)) * apply old tool damage to all mobs ([91b121f](https://github.com/kernitus/BukkitOldCombatMechanics/commit/91b121ff009971586c877778e6a75309088ba667)), closes [#735](https://github.com/kernitus/BukkitOldCombatMechanics/issues/735) * chorus fruit tp into blocks ([bba1ecb](https://github.com/kernitus/BukkitOldCombatMechanics/commit/bba1ecb62ec9faf1526189f308798d3b25f43cf9)), closes [#748](https://github.com/kernitus/BukkitOldCombatMechanics/issues/748) * clear modules list on reload ([ebdfd10](https://github.com/kernitus/BukkitOldCombatMechanics/commit/ebdfd101ae1393dbf97c431726b09ea797cc267d)) * double strength effect when old-potion-effects disabled ([4cecb64](https://github.com/kernitus/BukkitOldCombatMechanics/commit/4cecb649c8e03c0c2fd593b907da778e3f7dc453)), closes [#781](https://github.com/kernitus/BukkitOldCombatMechanics/issues/781) * fire damage overwriting lastDamage ([9af8a0f](https://github.com/kernitus/BukkitOldCombatMechanics/commit/9af8a0fa796513ab88588612f5551c5bf582db32)), closes [#707](https://github.com/kernitus/BukkitOldCombatMechanics/issues/707) * legacy (pre-1.11) sweep detection ([2825b35](https://github.com/kernitus/BukkitOldCombatMechanics/commit/2825b35b4c6b0b879389da170e6d85b9441d9799)) * negative last damage ([1321717](https://github.com/kernitus/BukkitOldCombatMechanics/commit/1321717288ec9624065d86b00aa441f9a1404b52)), closes [#765](https://github.com/kernitus/BukkitOldCombatMechanics/issues/765) * only strip consumable on swords ([e01faea](https://github.com/kernitus/BukkitOldCombatMechanics/commit/e01faea183d8387371dbd62e89fb847deb2fc38e)), closes [#841](https://github.com/kernitus/BukkitOldCombatMechanics/issues/841) * reflection error on weapon enchant ([10ff4ce](https://github.com/kernitus/BukkitOldCombatMechanics/commit/10ff4ceead5147b87c13ffea1401ef716596b80c)), closes [#840](https://github.com/kernitus/BukkitOldCombatMechanics/issues/840) * skip unknown sound packets ([cfa1e58](https://github.com/kernitus/BukkitOldCombatMechanics/commit/cfa1e58b5b5e481e1427458d22a98e487b32a621)) * unknown particles. ([1408720](https://github.com/kernitus/BukkitOldCombatMechanics/commit/140872008929ecc49918bdf0cc8e40d226957054)), closes [#825](https://github.com/kernitus/BukkitOldCombatMechanics/issues/825) * weakness calc on >=1.20 ([f502adb](https://github.com/kernitus/BukkitOldCombatMechanics/commit/f502adbbece03875e491bd1f39e4a45d1f498802)) * weakness calculations for amplifier > 1 ([d866015](https://github.com/kernitus/BukkitOldCombatMechanics/commit/d86601504eb6d16481e18946cf07e7432039cd92)) ### Performance * **attack-cooldown-tracker:** gate sampler by API presence and use HashMap for stable caching ([b605501](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b605501b40d350457d5227ce24c9c9a9522ed1f9)) * **disable-enderpearl-cooldown:** use HashMap and lazily drop expired cooldown entries ([83ff726](https://github.com/kernitus/BukkitOldCombatMechanics/commit/83ff726c5a9a2c2e6cc16571ce6e2d37123341ab)) * **fishing-rod-velocity:** replace per-hook gravity tasks with single shared tick runner ([5856bed](https://github.com/kernitus/BukkitOldCombatMechanics/commit/5856bed51830c51b0b6c205cb010fcb8dd9be0ac)) * **old-armour-durability:** replace per-explosion suppression task with shared 1-tick expiry cleaner ([c7932d6](https://github.com/kernitus/BukkitOldCombatMechanics/commit/c7932d6f0b32966ad38cdb81f8c83b14ca438478)) * **old-player-regen:** switch to tick-based interval tracking with shared counter task ([4f8df3c](https://github.com/kernitus/BukkitOldCombatMechanics/commit/4f8df3c5d0781240a46a4ed7e1ce10043aafb8d1)) * **player-knockback:** replace per-hit cleanup tasks with shared 1-tick expiry cleaner ([9667ef5](https://github.com/kernitus/BukkitOldCombatMechanics/commit/9667ef539e033ede2b97fadf309cd805df6900c5)) * **shield-damage-reduction:** replace per-hit fully-blocked cleanup tasks with shared 1-tick expiry cleaner ([a18b1ef](https://github.com/kernitus/BukkitOldCombatMechanics/commit/a18b1efec039c35b12f2c7c53dcc2be875545b29)) * **sword-block:** reduce amount of recurring tasks ([a08b5b4](https://github.com/kernitus/BukkitOldCombatMechanics/commit/a08b5b47bc5c1645db885ffca794e3ac7d9592ba)) * use one task to clear EDBEE map ([11ec51b](https://github.com/kernitus/BukkitOldCombatMechanics/commit/11ec51bd609339b8e41d74ef2d8697c3083a7d5f)) ## [2.2.0](https://github.com/kernitus/BukkitOldCombatMechanics/compare/v2.1.0...v2.2.0) (2025-10-14) ### Features * add fallback sound reflection logic ([1592dc2](https://github.com/kernitus/BukkitOldCombatMechanics/commit/1592dc249870ad3113b924cdebd41cbc36b68ad5)) ### Bug Fixes * ocm mode permissions ([e2f0369](https://github.com/kernitus/BukkitOldCombatMechanics/commit/e2f0369f294e250e8cfc474bbd1121498ecf09fe)), closes [#818](https://github.com/kernitus/BukkitOldCombatMechanics/issues/818) * update checker versioning logic ([8d88a49](https://github.com/kernitus/BukkitOldCombatMechanics/commit/8d88a49d0fa1e8c7dfa7c48cf66c8399c766d6e0)) * use reflection for inventory view ([462e536](https://github.com/kernitus/BukkitOldCombatMechanics/commit/462e536628f3df544c9cf0fe42705eff46b7d4f6)), closes [#812](https://github.com/kernitus/BukkitOldCombatMechanics/issues/812) ### Documentation * update issue templates ([5927729](https://github.com/kernitus/BukkitOldCombatMechanics/commit/5927729ea5fcca44a6218b10f40cec3f8ce3d4a3)) * update issue templates ([09fd3c5](https://github.com/kernitus/BukkitOldCombatMechanics/commit/09fd3c556ad02d25caa875e7dfe5854888a920cf)) * use yaml issue forms ([fc51924](https://github.com/kernitus/BukkitOldCombatMechanics/commit/fc51924504e3718b9829f4a7deca7a8701000f9f)) ## [2.1.0](https://github.com/kernitus/BukkitOldCombatMechanics/compare/v2.0.4...v2.1.0) (2025-08-21) ### Features * compat with 1.21.8 enums ([68c51ab](https://github.com/kernitus/BukkitOldCombatMechanics/commit/68c51ab8803da56f477660af247c37e5171bc581)) * make config upgrader remove deprecated keys ([e728374](https://github.com/kernitus/BukkitOldCombatMechanics/commit/e72837462fb8c512c9971c1e7d9376c82f37e741)) * remove deprecated modules ([da3d5f0](https://github.com/kernitus/BukkitOldCombatMechanics/commit/da3d5f0b28990d8f654b8557e68f54f41e8b5a60)) ### Bug Fixes * check fishing knockback module enabled when reeling in ([31e3877](https://github.com/kernitus/BukkitOldCombatMechanics/commit/31e3877330cdd820173a5d89e021919b153c6988)), closes [#803](https://github.com/kernitus/BukkitOldCombatMechanics/issues/803) * disable attack sounds not working in >1.21 ([b355322](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b355322f9b3f5e1c2b1e889684d6242f08ceee92)), closes [#794](https://github.com/kernitus/BukkitOldCombatMechanics/issues/794) * ExceptionInInitialiserError in enchantment compat ([b2379cc](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b2379cc17e309b035c2acb396392723f15ed3ee2)), closes [#782](https://github.com/kernitus/BukkitOldCombatMechanics/issues/782) * improve sound packet compatibility ([4ef28fb](https://github.com/kernitus/BukkitOldCombatMechanics/commit/4ef28fb7bd63631fa4b6f0366d23dd1e159aa115)), closes [#780](https://github.com/kernitus/BukkitOldCombatMechanics/issues/780) * null pointer in potion compat ([b30e27d](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b30e27ddb32d210371152feee8d337f27ea8f495)), closes [#791](https://github.com/kernitus/BukkitOldCombatMechanics/issues/791) * unmentioned worlds modesets not allowed [#792](https://github.com/kernitus/BukkitOldCombatMechanics/issues/792) ([95c9446](https://github.com/kernitus/BukkitOldCombatMechanics/commit/95c9446edbd0fe56bce0864798cf8d1c70865f8b)) ### Refactoring * improve fishing knockback cross-version compat ([d119c9f](https://github.com/kernitus/BukkitOldCombatMechanics/commit/d119c9f35e1a89be8fb8d03573041cfc2ae2d418)) ## [2.0.4](https://github.com/kernitus/BukkitOldCombatMechanics/compare/2.0.3...v2.0.4) (2024-10-28) ### Bug Fixes * avoid ghost items after sword block restore ([822fb1f](https://github.com/kernitus/BukkitOldCombatMechanics/commit/822fb1fa147fc49266cb9f0668869959e341982e)), closes [#749](https://github.com/kernitus/BukkitOldCombatMechanics/issues/749) * don't prevent moving shield to chests in disable offhand module ([b299df2](https://github.com/kernitus/BukkitOldCombatMechanics/commit/b299df2d21ace1c7e88b1ee8fafb297e2a9347e8)) * error when right clicking air while holding block in <1.13 ([cbc0c4b](https://github.com/kernitus/BukkitOldCombatMechanics/commit/cbc0c4bc8bf0afd56005699ce70f86ec9b637646)), closes [#754](https://github.com/kernitus/BukkitOldCombatMechanics/issues/754) * listen to dynamically loaded worlds for modesets ([f5b59d7](https://github.com/kernitus/BukkitOldCombatMechanics/commit/f5b59d7537d410fac35fbb4e0181a61a485ae1a5)), closes [#747](https://github.com/kernitus/BukkitOldCombatMechanics/issues/747) * resolve elytras always unequipped by removing out-of-scope module ([07106e6](https://github.com/kernitus/BukkitOldCombatMechanics/commit/07106e61a220ec4137a3de200a393cf6aaa50be7)), closes [#725](https://github.com/kernitus/BukkitOldCombatMechanics/issues/725) * fix sword blocking shield ending up in inventory on world change ([8aa3fa3](https://github.com/kernitus/BukkitOldCombatMechanics/commit/8aa3fa33081c1e1b1a48baa484fd6946b275362b)), closes [#753](https://github.com/kernitus/BukkitOldCombatMechanics/issues/753) ================================================ FILE: LICENCE ================================================ Mozilla Public License Version 2.0 ================================== 1. Definitions -------------- 1.1. "Contributor" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software. 1.2. "Contributor Version" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution. 1.3. "Contribution" means Covered Software of a particular Contributor. 1.4. "Covered Software" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof. 1.5. "Incompatible With Secondary Licenses" means (a) that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or (b) that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License. 1.6. "Executable Form" means any form of the work other than Source Code Form. 1.7. "Larger Work" means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software. 1.8. "License" means this document. 1.9. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License. 1.10. "Modifications" means any of the following: (a) any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or (b) any new file in Source Code Form that contains any Covered Software. 1.11. "Patent Claims" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version. 1.12. "Secondary License" means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses. 1.13. "Source Code Form" means the form of the work preferred for making modifications. 1.14. "You" (or "Your") means an individual or a legal entity exercising rights under this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity. 2. License Grants and Conditions -------------------------------- 2.1. Grants Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license: (a) under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and (b) under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version. 2.2. Effective Date The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution. 2.3. Limitations on Grant Scope The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor: (a) for any code that a Contributor has removed from Covered Software; or (b) for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or (c) under Patent Claims infringed by Covered Software in the absence of its Contributions. This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4). 2.4. Subsequent Licenses No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3). 2.5. Representation Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License. 2.6. Fair Use This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents. 2.7. Conditions Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1. 3. Responsibilities ------------------- 3.1. Distribution of Source Form All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients' rights in the Source Code Form. 3.2. Distribution of Executable Form If You distribute Covered Software in Executable Form then: (a) such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and (b) You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License. 3.3. Distribution of a Larger Work You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s). 3.4. Notices You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies. 3.5. Application of Additional Terms You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction. 4. Inability to Comply Due to Statute or Regulation --------------------------------------------------- If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it. 5. Termination -------------- 5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice. 5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate. 5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination. ************************************************************************ * * * 6. Disclaimer of Warranty * * ------------------------- * * * * Covered Software is provided under this License on an "as is" * * basis, without warranty of any kind, either expressed, implied, or * * statutory, including, without limitation, warranties that the * * Covered Software is free of defects, merchantable, fit for a * * particular purpose or non-infringing. The entire risk as to the * * quality and performance of the Covered Software is with You. * * Should any Covered Software prove defective in any respect, You * * (not any Contributor) assume the cost of any necessary servicing, * * repair, or correction. This disclaimer of warranty constitutes an * * essential part of this License. No use of any Covered Software is * * authorized under this License except under this disclaimer. * * * ************************************************************************ ************************************************************************ * * * 7. Limitation of Liability * * -------------------------- * * * * Under no circumstances and under no legal theory, whether tort * * (including negligence), contract, or otherwise, shall any * * Contributor, or anyone who distributes Covered Software as * * permitted above, be liable to You for any direct, indirect, * * special, incidental, or consequential damages of any character * * including, without limitation, damages for lost profits, loss of * * goodwill, work stoppage, computer failure or malfunction, or any * * and all other commercial damages or losses, even if such party * * shall have been informed of the possibility of such damages. This * * limitation of liability shall not apply to liability for death or * * personal injury resulting from such party's negligence to the * * extent applicable law prohibits such limitation. Some * * jurisdictions do not allow the exclusion or limitation of * * incidental or consequential damages, so this exclusion and * * limitation may not apply to You. * * * ************************************************************************ 8. Litigation ------------- Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims. 9. Miscellaneous ---------------- This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor. 10. Versions of the License --------------------------- 10.1. New Versions Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number. 10.2. Effect of New Versions You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward. 10.3. Modified Versions If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License). 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached. Exhibit A - Source Code Form License Notice ------------------------------------------- This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/. If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. You may add additional accurate notices of copyright ownership. Exhibit B - "Incompatible With Secondary Licenses" Notice --------------------------------------------------------- This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0. ================================================ FILE: README.md ================================================

## by kernitus and Rayzr522 Fine‑tune Minecraft combat, movement, and item balance without breaking your server. OldCombatMechanics is a free, open‑source toolkit for Spigot & Paper that lets you mix 1.8‑style snappiness with modern features, per world and per player. **Why servers pick OCM** ✨ - 🧩 **Modular:** enable only what you need: cooldowns, tool damage, knockback, shields, potions, reach, sounds, more. - 🚀 **Performant:** lean listeners only enabled as needed; reflection lookups are cached and recurring tasks are minimised (shared where possible) to keep tick time low on busy PvP servers. - 🗺️ **Modesets:** ship different rules for different worlds or players; perfect for mixed PvP/PvE, minigames, or duels. - ⏪ **Backwards‑friendly:** runs on Java 8+, supports 1.9 to latest; integrates cleanly with PlaceholderAPI and PacketEvents. - ✅ **Tested for you:** live integration tests run real Paper servers across multiple versions every build. - 💸 **Zero cost:** fully open source, optional basic telemetry (bStats only), no paywalls. **Quick start** ⚡ 1. Drop the jar into `plugins/` (Spigot or Paper-derivatives 1.9+). 2. Restart and edit `config.yml` to pick your modules and modesets. 3. Use `/ocm reload` to apply changes instantly. 4. Hand players `/ocm modeset ` to let them choose their ruleset.

Paper Spigot Bukkit

## 🧰 Modesets - Per-player/per-world presets that decide which features are active; each world has an allowed list and a default modeset. - Let players pick ( `/ocm modeset ` ) to run, for example, 1.8-style PvP in an arena world while keeping vanilla rules in survival. ## ⚙ Configurable Features Features are grouped in `module`s as listed below, and can be individually configured and disabled. Disabled modules will have no impact on server performance. #### ⚔ Combat *Tweak timing, damage, and reach.* - **Attack cooldown:** adjust or remove 1.9+ cooldown - **Attack frequency:** set global hit delay - **Tool damage:** pre-1.9 weapon values - **Attack range (Paper 1.21.11+):** 1.8-style reach - **Critical hits:** control crit multiplier - **Player regen:** tune regen rates #### 🤺 Armour *Balance defence and wear.* - **Armour strength:** scale armour protection - **Armour durability:** change durability loss #### 🛡 Swords & Shields *Control block and sweep behaviour.* - **Sword blocking:** restore old right-click block; on Paper 1.21.2+ we also add the native sword blocking animation via the consumable component - **Shield damage reduction:** scale shield protection - **Sword sweep:** enable or disable sweeps - **Sword sweep particles:** hide or show sweep visuals #### 🌬 Knockback *Shape knockback per source.* - **Player knockback:** adjust PvP knockback - **Fishing knockback:** fishing-rod knockback - **Fishing rod velocity:** pull speed - **Projectile knockback:** arrows and other projectiles #### 🧙 Gapples & Potions *Change consumable power.* - **Golden apple crafting and effects:** notch and normal - **Potion effects and duration:** old-style values - **Chorus fruit:** teleport behaviour and range #### ❌ New feature disabling *Toggle later-version mechanics.* - **Item crafting:** block selected recipes - **Offhand:** disable offhand use - **New attack sounds:** mute new swing sounds - **Enderpearl cooldown:** enable or remove cooldown - **Brewing stand refuel:** alter fuel use - **Burn delay:** adjust fire tick delay ## 🔌 Compatibility & Testing - OCM targets Spigot 1.9+ and runs on Java 8 and up. - We stick to Spigot/Paper APIs for forward compatibility; NMS/reflection is used only when necessary. - Integration tests boot real servers on 1.9.4, 1.12, 1.19.2, and 1.21.11 each build to verify behaviour. - Most plugins work fine with OCM. Explicitly tested integrations include PlaceholderAPI (see [wiki](https://github.com/kernitus/BukkitOldCombatMechanics/wiki/PlaceholderAPI)). ## 🧾 Licence - Source code in this repository is under the Mozilla Public License 2.0 (MPL‑2.0). - Pre-built jars bundle PacketEvents (GPLv3). Those binary distributions are provided under GPLv3 terms due to the included dependency. - If you build a jar without PacketEvents, you may distribute that build under MPL‑2.0, subject to its terms. ## ⚡ Development Builds Oftentimes a particular bug fix or feature has already been implemented, but a new version of OCM has not been released yet. You can find the most up-to-date version of the plugin on [Hangar](https://hangar.papermc.io/kernitus/OldCombatMechanics/versions?channel=Snapshot&platform=PAPER). ## 🤝 Contributions If you are interested in contributing, please [check this page first](.github/CONTRIBUTING.md).
bStats ================================================ FILE: build.gradle.kts ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar import groovy.json.JsonSlurper import io.papermc.hangarpublishplugin.model.Platforms import org.gradle.api.Action import org.gradle.api.attributes.java.TargetJvmVersion import org.gradle.api.file.FileCopyDetails import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import xyz.jpenilla.runpaper.task.RunServer import java.io.ByteArrayOutputStream import java.io.Closeable import java.io.Serializable import java.net.URI import java.nio.file.Files import java.security.MessageDigest val paperVersion: List = (property("gameVersions") as String) .split(",") .map { it.trim() } plugins { `java-library` kotlin("jvm") version "2.3.0" id("com.gradleup.shadow") version "9.3.0" id("xyz.jpenilla.run-paper") version "3.0.2" idea id("io.papermc.hangar-publish-plugin") version "0.1.4" } // Make sure javadocs are available to IDE idea { module { isDownloadJavadoc = true isDownloadSources = true } } repositories { mavenCentral() maven("https://repo.papermc.io/repository/maven-public/") // Spigot API maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") maven("https://oss.sonatype.org/content/repositories/snapshots") maven("https://oss.sonatype.org/content/repositories/central") // PacketEvents maven("https://repo.codemc.io/repository/maven-releases/") maven("https://repo.codemc.io/repository/maven-snapshots/") // Placeholder API maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") // CodeMC Repo for bStats maven("https://repo.codemc.org/repository/maven-public/") // Auth library from Minecraft maven("https://libraries.minecraft.net/") } group = "kernitus.plugin.OldCombatMechanics" version = "2.5.0-beta" // x-release-please-version description = "OldCombatMechanics" java { toolchain { // We can build with Java 17 but still support MC >=1.9 // This is because MC >=1.9 server can be run with higher Java versions languageVersion.set(JavaLanguageVersion.of(17)) } } sourceSets { val integrationTest by creating { kotlin.setSrcDirs(listOf("src/integrationTest/kotlin")) resources.setSrcDirs(listOf("src/integrationTest/resources")) compileClasspath += main.get().output runtimeClasspath += output + main.get().output } } configurations { val integrationTestImplementation by getting { extendsFrom(configurations.implementation.get()) } create("integrationTestServerPlugins") { isCanBeConsumed = false isCanBeResolved = true } } configurations.named("compileClasspath") { attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 17) } configurations.named("integrationTestCompileClasspath") { attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 17) } dependencies { implementation("org.bstats:bstats-bukkit:3.1.0") // Shaded in by Bukkit compileOnly("io.netty:netty-all:4.1.130.Final") // Placeholder API compileOnly("me.clip:placeholderapi:2.11.6") // For BSON file serialisation implementation("org.mongodb:bson:5.6.2") // Spigot compileOnly("org.spigotmc:spigot-api:1.21.11-R0.1-SNAPSHOT") // JSR-305 annotations (javax.annotation.Nullable) compileOnly("com.google.code.findbugs:jsr305:3.0.2") // PacketEvents implementation("com.github.retrooper:packetevents-spigot:2.11.2") // XSeries implementation("com.github.cryptomorin:XSeries:13.6.0") // For ingametesting // Mojang mappings for NMS /* compileOnly("com.mojang:authlib:6.0.54") paperweight.paperDevBundle("1.19.2-R0.1-SNAPSHOT") // For reflection remapping implementation("xyz.jpenilla:reflection-remapper:0.1.3") */ // Integration test dependencies implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.3.0") add("integrationTestImplementation", "org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.3.0") add("integrationTestImplementation", "org.jetbrains.kotlin:kotlin-test:2.3.0") add("integrationTestImplementation", "org.jetbrains.kotlin:kotlin-reflect:2.3.0") add("integrationTestImplementation", "io.kotest:kotest-runner-junit5-jvm:5.9.1") add("integrationTestImplementation", "io.kotest:kotest-assertions-core-jvm:5.9.1") add("integrationTestImplementation", "net.kyori:adventure-api:4.26.1") add("integrationTestImplementation", "xyz.jpenilla:reflection-remapper:0.1.3") add("integrationTestCompileOnly", "org.spigotmc:spigot-api:1.21.11-R0.1-SNAPSHOT") add("integrationTestCompileOnly", "com.mojang:authlib:6.0.54") add("integrationTestCompileOnly", "io.netty:netty-all:4.1.130.Final") } // Substitute ${pluginVersion} in plugin.yml with version defined above class ExpandPluginVersionAction( private val version: String, ) : Action, Serializable { override fun execute(details: FileCopyDetails) { details.expand(mapOf("pluginVersion" to version)) } } val pluginVersion = project.version.toString() val expandPluginVersionAction = ExpandPluginVersionAction(pluginVersion) tasks.named("processResources") { inputs.property("pluginVersion", pluginVersion) filesMatching("plugin.yml", expandPluginVersionAction) } tasks.withType { options.encoding = "UTF-8" options.release.set(8) } val shadowJarTask = tasks.named("shadowJar") { dependsOn("jar") archiveFileName.set("${project.name}.jar") dependencies { exclude(dependency("org.jetbrains.kotlin:.*")) relocate("org.bstats", "kernitus.plugin.OldCombatMechanics.lib.bstats") relocate("com.cryptomorin.xseries", "kernitus.plugin.OldCombatMechanics.lib.xseries") relocate("com.github.retrooper.packetevents", "kernitus.plugin.OldCombatMechanics.lib.packetevents.api") relocate("io.github.retrooper.packetevents", "kernitus.plugin.OldCombatMechanics.lib.packetevents.impl") } } // For ingametesting /* tasks.reobfJar { outputJar.set(File(buildDir, "libs/${project.name}.jar")) } */ tasks.assemble { // For ingametesting // dependsOn("reobfJar") dependsOn("shadowJar") } kotlin { jvmToolchain(17) } tasks.withType().configureEach { compilerOptions.jvmTarget.set(JvmTarget.JVM_1_8) } val relocateIntegrationTestClasses = tasks.register("relocateIntegrationTestClasses") { archiveClassifier.set("tests-relocated") dependsOn("compileIntegrationTestKotlin") configurations = emptyList() from(sourceSets["integrationTest"].output) relocate("com.github.retrooper.packetevents", "kernitus.plugin.OldCombatMechanics.lib.packetevents.api") relocate("io.github.retrooper.packetevents", "kernitus.plugin.OldCombatMechanics.lib.packetevents.impl") } val integrationTestJarTask = tasks.register("integrationTestJar") { archiveClassifier.set("tests") duplicatesStrategy = DuplicatesStrategy.EXCLUDE dependsOn(relocateIntegrationTestClasses) from(relocateIntegrationTestClasses.flatMap { it.archiveFile }.map { zipTree(it.asFile) }) project.configurations["integrationTestRuntimeClasspath"].forEach { file: File -> if (file.name.contains("packetevents", ignoreCase = true)) { return@forEach } from(if (file.isDirectory) file else zipTree(file)) } exclude("META-INF/*.SF") exclude("META-INF/*.DSA") exclude("META-INF/*.RSA") exclude("META-INF/*.EC") exclude("META-INF/*.MF") exclude("module-info.class") exclude("META-INF/versions/**/module-info.class") } val integrationTestMinecraftVersion = (findProperty("integrationTestMinecraftVersion") as String?) ?: "1.19.2" val defaultIntegrationTestVersions = listOf(integrationTestMinecraftVersion, "1.21.11", "1.12", "1.9.4") .distinct() val integrationTestVersions: List = (findProperty("integrationTestVersions") as String?) ?.split(",") ?.map { it.trim() } ?.filter { it.isNotEmpty() } ?.ifEmpty { defaultIntegrationTestVersions } ?: defaultIntegrationTestVersions val integrationTestJavaVersionLegacy = (findProperty("integrationTestJavaVersionLegacy") as String?)?.toInt() ?: 17 val integrationTestJavaVersionLegacyPre13 = (findProperty("integrationTestJavaVersionLegacyPre13") as String?)?.toInt() ?: 8 val integrationTestJavaVersionLegacy16 = (findProperty("integrationTestJavaVersionLegacy16") as String?)?.toInt() ?: 11 val integrationTestJavaVersionModern = (findProperty("integrationTestJavaVersionModern") as String?)?.toInt() ?: 25 fun parseMinecraftVersion(version: String): Triple { val parts = version.split(".") val major = parts.getOrNull(0)?.toIntOrNull() ?: 0 val minor = parts.getOrNull(1)?.toIntOrNull() ?: 0 val patch = parts.getOrNull(2)?.toIntOrNull() ?: 0 return Triple(major, minor, patch) } fun needsLegacyVanillaJar(version: String): Boolean { val (major, minor, _) = parseMinecraftVersion(version) return major == 1 && minor <= 12 } fun requiresModernJava(version: String): Boolean { val (major, minor, patch) = parseMinecraftVersion(version) if (major > 1) return true if (minor > 20) return true return minor == 20 && patch >= 5 } fun requiredJavaVersion(version: String): Int { if (needsLegacyVanillaJar(version)) return integrationTestJavaVersionLegacyPre13 val (_, minor, _) = parseMinecraftVersion(version) if (minor <= 16) return integrationTestJavaVersionLegacy16 return if (requiresModernJava(version)) integrationTestJavaVersionModern else integrationTestJavaVersionLegacy } data class KotestSummary( val specsPassed: Int?, val specsFailed: Int?, val specsTotal: Int?, val testsPassed: Int?, val testsFailed: Int?, val testsIgnored: Int?, val testsTotal: Int?, val failures: List, val failureDetails: List, ) fun parseKotestSummary(logFile: File): KotestSummary? { if (!logFile.exists()) return null val lines = logFile.readLines() var inFailures = false var blockContext: String? = null // "specs" or "tests" var specsPassed: Int? = null var specsFailed: Int? = null var specsTotal: Int? = null var testsPassed: Int? = null var testsFailed: Int? = null var testsIgnored: Int? = null var testsTotal: Int? = null val failures = mutableListOf() val failureDetails = mutableListOf() val numberLine = Regex("^(\\d+) (passed|failed|ignored|total)$") val inlineSpecsLine = Regex("^Specs:\\s*(\\d+) passed,\\s*(\\d+) failed,\\s*(\\d+) total$") val inlineTestsLine = Regex("^Tests:\\s*(\\d+) passed,\\s*(\\d+) failed,\\s*(\\d+) ignored,\\s*(\\d+) total$") val stackTopLine = Regex("^\\s*[^\\s].*\\(([^)]+:\\d+)\\)\\s*$") var lastTestName: String? = null var pendingFailureName: String? = null var pendingFailureMessage: String? = null for (raw in lines) { val line = raw.substringAfter("]:", raw).trim() when { line.startsWith(">> There were test failures") -> { inFailures = true blockContext = null } line.startsWith("Specs:") -> { inFailures = false val inline = inlineSpecsLine.matchEntire(line) if (inline != null) { specsPassed = inline.groupValues[1].toInt() specsFailed = inline.groupValues[2].toInt() specsTotal = inline.groupValues[3].toInt() blockContext = null } else { blockContext = "specs" } } line.startsWith("Tests:") -> { inFailures = false val inline = inlineTestsLine.matchEntire(line) if (inline != null) { testsPassed = inline.groupValues[1].toInt() testsFailed = inline.groupValues[2].toInt() testsIgnored = inline.groupValues[3].toInt() testsTotal = inline.groupValues[4].toInt() blockContext = null } else { blockContext = "tests" } } inFailures -> { val cleaned = line.removePrefix("-").trim() if (cleaned.isNotBlank()) { failures.add(cleaned) } } line.startsWith("- ") -> { lastTestName = line.removePrefix("-").trim() } line == "FAILED" -> { pendingFailureName = lastTestName pendingFailureMessage = null } pendingFailureName != null && pendingFailureMessage == null && line.isNotBlank() -> { // First line after FAILED is usually the assertion message. pendingFailureMessage = line } pendingFailureName != null && pendingFailureMessage != null -> { val match = stackTopLine.matchEntire(line) if (match != null) { val location = match.groupValues[1] val name = pendingFailureName!! val message = pendingFailureMessage!! failureDetails.add("$name: $message ($location)") pendingFailureName = null pendingFailureMessage = null } } blockContext != null -> { val match = numberLine.matchEntire(line) if (match != null) { val value = match.groupValues[1].toInt() when (blockContext) { "specs" -> { when (match.groupValues[2]) { "passed" -> specsPassed = value "failed" -> specsFailed = value "total" -> specsTotal = value } } "tests" -> { when (match.groupValues[2]) { "passed" -> testsPassed = value "failed" -> testsFailed = value "ignored" -> testsIgnored = value "total" -> testsTotal = value } } } } } } } if ( specsPassed == null && specsFailed == null && specsTotal == null && testsPassed == null && testsFailed == null && testsIgnored == null && testsTotal == null && failures.isEmpty() ) { return null } return KotestSummary( specsPassed, specsFailed, specsTotal, testsPassed, testsFailed, testsIgnored, testsTotal, failures, failureDetails.distinct(), ) } fun sha1(file: File): String { val digest = MessageDigest.getInstance("SHA-1") file.inputStream().use { input -> val buffer = ByteArray(8192) while (true) { val read = input.read(buffer) if (read <= 0) break digest.update(buffer, 0, read) } } return digest.digest().joinToString("") { "%02x".format(it) } } tasks.register("integrationTest") { group = "verification" description = "Runs integration tests against all configured Paper versions." dependsOn("integrationTestMatrix") } tasks.named("runServer") { enabled = false description = "Disabled. Use integrationTest/integrationTestMatrix instead." } tasks.withType().configureEach { notCompatibleWithConfigurationCache("run-paper tasks access Project at execution time.") } val integrationTestMatrixTasks = mutableListOf>() var previousMatrixTask: TaskProvider? = null val kotestSpecFilterProvider = providers.systemProperty("kotest.filter.specs") val kotestTestFilterProvider = providers.systemProperty("kotest.filter.tests") fun versionTaskSuffix(version: String): String = version.replace(Regex("[^A-Za-z0-9]"), "_") for (version in integrationTestVersions) { val suffix = versionTaskSuffix(version) val runDir = file("run/$version") val resultFile = runDir.resolve("plugins/OldCombatMechanicsTest/test-results.txt") val failuresFile = runDir.resolve("plugins/OldCombatMechanicsTest/test-failures.txt") val vanillaCacheFile = runDir.resolve("cache/mojang_$version.jar") val logFile = layout.buildDirectory.file("integration-test-logs/$suffix.log") val writePropsTask = tasks.register("writeProperties$suffix") { encoding = "UTF-8" property("online-mode", false) destinationFile.set(runDir.resolve("server.properties")) } val downloadVanillaTask = if (needsLegacyVanillaJar(version)) { tasks.register("downloadVanilla$suffix") { outputs.file(vanillaCacheFile) notCompatibleWithConfigurationCache("Downloads vanilla server jar for legacy Paper versions.") doLast { val slurper = JsonSlurper() val manifestText = URI("https://piston-meta.mojang.com/mc/game/version_manifest_v2.json") .toURL() .readText() val manifest = slurper.parseText(manifestText) as Map<*, *> val versionsList = manifest["versions"] as? List> ?: throw GradleException("Invalid Mojang manifest format: missing 'versions' list.") val versionEntry = versionsList.firstOrNull { it["id"] == version } ?: throw GradleException("Minecraft version '$version' not found in Mojang manifest.") val versionUrl = versionEntry["url"] as String val versionMetaText = URI(versionUrl).toURL().readText() val versionMeta = slurper.parseText(versionMetaText) as Map<*, *> val downloads = versionMeta["downloads"] as Map<*, *> val serverInfo = downloads["server"] as Map<*, *> val serverUrl = serverInfo["url"] as String val serverSha1 = serverInfo["sha1"] as String if (vanillaCacheFile.exists()) { val existingSha1 = sha1(vanillaCacheFile) if (existingSha1.equals(serverSha1, ignoreCase = true)) { return@doLast } } else { vanillaCacheFile.parentFile.mkdirs() } val tmpFile = Files.createTempFile("mc-server-$version-", ".jar").toFile() URI(serverUrl).toURL().openStream().use { input -> tmpFile.outputStream().use { output -> input.copyTo(output) } } val downloadedSha1 = sha1(tmpFile) if (!downloadedSha1.equals(serverSha1, ignoreCase = true)) { tmpFile.delete() throw GradleException( "Downloaded Minecraft server jar hash mismatch for $version. Expected $serverSha1, got $downloadedSha1.", ) } tmpFile.copyTo(vanillaCacheFile, overwrite = true) tmpFile.delete() } } } else { null } val runServerTask = tasks.register("runServer$suffix") { dependsOn(writePropsTask) downloadVanillaTask?.let { dependsOn(it) } runDirectory.set(runDir) minecraftVersion(version) jvmArgs("-Dcom.mojang.eula.agree=true") kotestSpecFilterProvider.orNull?.takeIf { it.isNotBlank() }?.let { jvmArgs("-Dkotest.filter.specs=$it") } kotestTestFilterProvider.orNull?.takeIf { it.isNotBlank() }?.let { jvmArgs("-Dkotest.filter.tests=$it") } if (needsLegacyVanillaJar(version)) { // Skip the legacy Paper "outdated build" startup sleep. jvmArgs("-DIReallyKnowWhatIAmDoingISwear=true") } javaLauncher.set( javaToolchains.launcherFor { languageVersion.set(JavaLanguageVersion.of(requiredJavaVersion(version))) }, ) pluginJars.from(shadowJarTask.flatMap { it.archiveFile }) pluginJars.from(integrationTestJarTask.flatMap { it.archiveFile }) pluginJars.from(configurations["integrationTestServerPlugins"]) doFirst { val log = logFile.get().asFile log.parentFile.mkdirs() val stream = log.outputStream() standardOutput = stream errorOutput = stream } doLast { (standardOutput as? Closeable)?.close() } doFirst { if (resultFile.exists()) { resultFile.delete() } if (failuresFile.exists()) { failuresFile.delete() } val ocmConfigFile = runDir.resolve("plugins/OldCombatMechanics/config.yml") if (ocmConfigFile.exists()) { ocmConfigFile.delete() } } } val checkTask = tasks.register("checkTestResults$suffix") { doLast { if (!resultFile.exists()) { throw GradleException("Test results file not found for $version. Tests may not have run correctly.") } val result = resultFile.readText().trim() val log = logFile.get().asFile val summary = parseKotestSummary(log) summary?.let { val parts = mutableListOf() if (it.specsTotal != null) { parts.add("Specs: ${it.specsPassed ?: "?"} passed, ${it.specsFailed ?: "?"} failed, ${it.specsTotal} total") } if (it.testsTotal != null) { parts.add( "Tests: ${it.testsPassed ?: "?"} passed, ${it.testsFailed ?: "?"} failed, ${it.testsIgnored ?: 0} ignored, ${it.testsTotal} total", ) } if (it.failures.isNotEmpty()) { parts.add("Failures: ${it.failures.joinToString(", ")}") } if (it.failureDetails.isNotEmpty()) { parts.add("Reasons: ${it.failureDetails.take(2).joinToString("; ")}") } if (parts.isNotEmpty()) { logger.lifecycle("[$version] ${parts.joinToString(" | ")}") } } ?: run { val rel = log.relativeToOrNull(project.layout.projectDirectory.asFile)?.path ?: log.absolutePath logger.lifecycle("[$version] No Kotest summary parsed. Full log: $rel") } run { val rel = log.relativeToOrNull(project.layout.projectDirectory.asFile)?.path ?: log.absolutePath logger.lifecycle("[$version] Log: $rel") } if (failuresFile.exists()) { val lines = failuresFile.readLines().map { it.trim() }.filter { it.isNotEmpty() } if (lines.isNotEmpty()) { logger.lifecycle("[$version] Failure details: ${lines.take(5).joinToString(" | ")}") } } if (result == "FAIL") { throw GradleException("Integration tests failed for $version.") } else if (result != "PASS") { throw GradleException("Unknown test result for $version: $result") } logger.lifecycle("Integration tests passed for $version.") } } val testTask = tasks.register("integrationTest$suffix") { group = "verification" description = "Runs integration tests with a live Paper server ($version)." dependsOn(shadowJarTask, integrationTestJarTask, runServerTask) finalizedBy(checkTask) } val priorTask = previousMatrixTask if (priorTask != null) { // Chain tasks to enforce order and fail fast. testTask.configure { dependsOn(priorTask) } } previousMatrixTask = testTask integrationTestMatrixTasks.add(testTask) } tasks.register("integrationTestMatrix") { group = "verification" description = "Runs integration tests against multiple Paper versions." dependsOn(integrationTestMatrixTasks) } val versionStringProvider = providers.provider { project.version.toString() } val isReleaseProvider = versionStringProvider.map { !it.contains('-') } val gitShortHashProvider = providers .exec { commandLine("git", "rev-parse", "--short", "HEAD") }.standardOutput.asText .map { it.trim() } val gitChangelogProvider = providers .exec { commandLine("git", "log", "-1", "--pretty=%B") }.standardOutput.asText .map { it.trim() } val suffixedVersionProvider = providers.provider { val version = project.version.toString() if (!version.contains('-')) { version } else { "$version+${gitShortHashProvider.get()}" } } val changelogProvider = providers.environmentVariable("HANGAR_CHANGELOG").orElse(gitChangelogProvider) tasks.register("printIsRelease") { doLast { println(if (!project.version.toString().contains('-')) "true" else "false") } } hangarPublish { publications.register("plugin") { version.set(suffixedVersionProvider) channel.set(isReleaseProvider.map { if (it) "Release" else "Snapshot" }) id.set("OldCombatMechanics") apiKey.set(System.getenv("HANGAR_API_TOKEN")) changelog.set(changelogProvider) platforms { register(Platforms.PAPER) { jar.set(tasks.shadowJar.flatMap { it.archiveFile }) platformVersions.set(paperVersion) } } } } ================================================ FILE: gradle.properties ================================================ # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at https://mozilla.org/MPL/2.0/. gameVersions=1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21, 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20, 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19, 1.18.2, 1.18.1, 1.18, 1.17, 1.16, 1.15, 1.14, 1.13, 1.12, 1.11, 1.10, 1.9 # Disable configuration cache (run-paper tasks are not compatible). org.gradle.configuration-cache=false ================================================ FILE: gradlew ================================================ #!/bin/sh # # Copyright © 2015 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # SPDX-License-Identifier: Apache-2.0 # ############################################################################## # # Gradle start up script for POSIX generated by Gradle. # # Important for running: # # (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is # noncompliant, but you have some other compliant shell such as ksh or # bash, then to run this script, type that shell name before the whole # command line, like: # # ksh Gradle # # Busybox and similar reduced shells will NOT work, because this script # requires all of these POSIX shell features: # * functions; # * expansions «$var», «${var}», «${var:-default}», «${var+SET}», # «${var#prefix}», «${var%suffix}», and «$( cmd )»; # * compound commands having a testable exit status, especially «case»; # * various built-in commands including «command», «set», and «ulimit». # # Important for patching: # # (2) This script targets any POSIX shell, so it avoids extensions provided # by Bash, Ksh, etc; in particular arrays are avoided. # # The "traditional" practice of packing multiple parameters into a # space-separated string is a well documented source of bugs and security # problems, so this is (mostly) avoided, by progressively accumulating # options in "$@", and eventually passing that to Java. # # Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, # and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; # see the in-line comments for details. # # There are tweaks for specific operating systems such as AIX, CygWin, # Darwin, MinGW, and NonStop. # # (3) This script is generated from the Groovy template # https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt # within the Gradle project. # # You can find Gradle at https://github.com/gradle/gradle/. # ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link app_path=$0 # Need this for daisy-chained symlinks. while APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path [ -h "$app_path" ] do ls=$( ls -ld "$app_path" ) link=${ls#*' -> '} case $link in #( /*) app_path=$link ;; #( *) app_path=$APP_HOME$link ;; esac done # This is normally unused # shellcheck disable=SC2034 APP_BASE_NAME=${0##*/} # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD=maximum warn () { echo "$*" } >&2 die () { echo echo "$*" echo exit 1 } >&2 # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "$( uname )" in #( CYGWIN* ) cygwin=true ;; #( Darwin* ) darwin=true ;; #( MSYS* | MINGW* ) msys=true ;; #( NONSTOP* ) nonstop=true ;; esac # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD=$JAVA_HOME/jre/sh/java else JAVACMD=$JAVA_HOME/bin/java fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD=java if ! command -v java >/dev/null 2>&1 then die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi fi # Increase the maximum file descriptors if we can. if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then case $MAX_FD in #( max*) # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. # shellcheck disable=SC2039,SC3045 MAX_FD=$( ulimit -H -n ) || warn "Could not query maximum file descriptor limit" esac case $MAX_FD in #( '' | soft) :;; #( *) # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. # shellcheck disable=SC2039,SC3045 ulimit -n "$MAX_FD" || warn "Could not set maximum file descriptor limit to $MAX_FD" esac fi # Collect all arguments for the java command, stacking in reverse order: # * args from the command line # * the main class name # * -classpath # * -D...appname settings # * --module-path (only if needed) # * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. # For Cygwin or MSYS, switch paths to Windows format before running java if "$cygwin" || "$msys" ; then APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) JAVACMD=$( cygpath --unix "$JAVACMD" ) # Now convert the arguments - kludge to limit ourselves to /bin/sh for arg do if case $arg in #( -*) false ;; # don't mess with options #( /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath [ -e "$t" ] ;; #( *) false ;; esac then arg=$( cygpath --path --ignore --mixed "$arg" ) fi # Roll the args list around exactly as many times as the number of # args, so each arg winds up back in the position where it started, but # possibly modified. # # NB: a `for` loop captures its iteration list before it begins, so # changing the positional parameters here affects neither the number of # iterations, nor the values presented in `arg`. shift # remove old arg set -- "$@" "$arg" # push replacement arg done fi # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Collect all arguments for the java command: # * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, # and any embedded shellness will be escaped. # * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be # treated as '${Hostname}' itself on the command line. set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ "$@" # Stop when "xargs" is not available. if ! command -v xargs >/dev/null 2>&1 then die "xargs is not available" fi # Use "xargs" to parse quoted args. # # With -n1 it outputs one arg per line, with the quotes and backslashes removed. # # In Bash we could simply go: # # readarray ARGS < <( xargs -n1 <<<"$var" ) && # set -- "${ARGS[@]}" "$@" # # but POSIX shell has neither arrays nor command substitution, so instead we # post-process each arg (as a line of input to sed) to backslash-escape any # character that might be a shell metacharacter, then use eval to reverse # that process (while maintaining the separation between arguments), and wrap # the whole thing up as a single "set" statement. # # This will of course break if any of these variables contains a newline or # an unmatched quote. # eval "set -- $( printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | xargs -n1 | sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | tr '\n' ' ' )" '"$@"' exec "$JAVACMD" "$@" ================================================ FILE: gradlew.bat ================================================ @rem @rem Copyright 2015 the original author or authors. @rem @rem Licensed under the Apache License, Version 2.0 (the "License"); @rem you may not use this file except in compliance with the License. @rem You may obtain a copy of the License at @rem @rem https://www.apache.org/licenses/LICENSE-2.0 @rem @rem Unless required by applicable law or agreed to in writing, software @rem distributed under the License is distributed on an "AS IS" BASIS, @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem @rem SPDX-License-Identifier: Apache-2.0 @rem @if "%DEBUG%"=="" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%"=="" set DIRNAME=. @rem This is normally unused set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Resolve any "." and ".." in APP_HOME to make it shorter. for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if %ERRORLEVEL% equ 0 goto execute echo. 1>&2 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 echo. 1>&2 echo Please set the JAVA_HOME variable in your environment to match the 1>&2 echo location of your Java installation. 1>&2 goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto execute echo. 1>&2 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 echo. 1>&2 echo Please set the JAVA_HOME variable in your environment to match the 1>&2 echo location of your Java installation. 1>&2 goto fail :execute @rem Setup the command line @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* :end @rem End local scope for the variables with windows NT shell if %ERRORLEVEL% equ 0 goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! set EXIT_CODE=%ERRORLEVEL% if %EXIT_CODE% equ 0 set EXIT_CODE=1 if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% exit /b %EXIT_CODE% :mainEnd if "%OS%"=="Windows_NT" endlocal :omega ================================================ FILE: settings.gradle.kts ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ rootProject.name = "OldCombatMechanics" ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/AttackCompat.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.entity.Entity import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import java.lang.reflect.Method import java.util.concurrent.ConcurrentHashMap fun attackCompat(attacker: Player, target: Entity) { val apiAttack = attacker.javaClass.methods.firstOrNull { method -> method.name == "attack" && method.parameterCount == 1 && Entity::class.java.isAssignableFrom(method.parameterTypes[0]) } val useApiAttack = Reflector.versionIsNewerOrEqualTo(1, 12, 0) if (useApiAttack && apiAttack != null) { val beforeApiAttack = captureLivingAttackSignal(target) try { val apiResult = apiAttack.invoke(attacker, target) if (apiAttack.returnType == java.lang.Boolean.TYPE && apiResult == false) { // Explicit attack failure; continue with NMS candidates. } else if (beforeApiAttack == null) { return } else { val afterApiAttack = captureLivingAttackSignal(target) if (hasObservableHit(beforeApiAttack, afterApiAttack)) { return } } } catch (ignored: Exception) { // Fall through to NMS-based attack. } } // Fall back to NMS attack on legacy servers. val handleMethod = attacker.javaClass.methods.firstOrNull { method -> method.name == "getHandle" && method.parameterCount == 0 } ?: error("Failed to resolve CraftPlayer#getHandle for ${attacker.javaClass.name}") val attackerHandle = handleMethod.invoke(attacker) ?: error("CraftPlayer#getHandle returned null for ${attacker.javaClass.name}") val targetHandle = target.javaClass.methods.firstOrNull { method -> method.name == "getHandle" && method.parameterCount == 0 }?.invoke(target) ?: error("Failed to resolve CraftEntity#getHandle for ${target.javaClass.name}") val nmsAttackMethods = resolveNmsAttackMethods(attackerHandle.javaClass, targetHandle.javaClass) var falseResultCount = 0 var exceptionCount = 0 val attemptedMethods = ArrayList(nmsAttackMethods.size) for (method in nmsAttackMethods) { attemptedMethods += "${method.declaringClass.simpleName}#${method.name}:${method.returnType.simpleName}" try { val result = method.invoke(attackerHandle, targetHandle) if (method.returnType == java.lang.Boolean.TYPE && result == false) { falseResultCount++ continue } return } catch (ignored: Exception) { exceptionCount++ // Try the next candidate. } } // Legacy fallback: try Bukkit API even if we prefer NMS (helps 1.12 fake players) if (!useApiAttack && apiAttack != null) { runCatching { apiAttack.invoke(attacker, target); return } } error( "Failed to invoke NMS attack for attacker=${attackerHandle.javaClass.name} " + "target=${targetHandle.javaClass.name} (candidates=${nmsAttackMethods.size}, " + "falseResults=$falseResultCount, exceptions=$exceptionCount, attempted=$attemptedMethods)" ) } private data class LivingAttackSignal( val health: Double, val lastDamage: Double, val noDamageTicks: Int, ) private fun captureLivingAttackSignal(entity: Entity): LivingAttackSignal? { val living = entity as? LivingEntity ?: return null return LivingAttackSignal( health = living.health, lastDamage = living.lastDamage, noDamageTicks = living.noDamageTicks, ) } private fun hasObservableHit(before: LivingAttackSignal, after: LivingAttackSignal?): Boolean { if (after == null) return false if (after.health < before.health) return true if (after.noDamageTicks > before.noDamageTicks) return true return after.lastDamage > 0.0 && after.lastDamage != before.lastDamage } private val attackMethodCache = ConcurrentHashMap, List>() private fun resolveNmsAttackMethods(attackerHandleClass: Class<*>, targetHandleClass: Class<*>): List { return attackMethodCache.computeIfAbsent(attackerHandleClass) { buildAttackMethodCandidates(attackerHandleClass, targetHandleClass) } } private fun buildAttackMethodCandidates(attackerHandleClass: Class<*>, targetHandleClass: Class<*>): List { // Prefer explicit names if they exist, then fall back to signature-based heuristics. val explicit = listOfNotNull( Reflector.getMethodAssignable(attackerHandleClass, "attack", targetHandleClass), Reflector.getMethodAssignable(attackerHandleClass, "a", targetHandleClass), Reflector.getMethodAssignable(attackerHandleClass, "B", targetHandleClass) // legacy 1.12 variants ) if (explicit.isNotEmpty()) { explicit.forEach { it.isAccessible = true } return explicit } val candidates = collectAllMethods(attackerHandleClass) .asSequence() .filter { it.parameterCount == 1 } .filter { it.parameterTypes[0].isAssignableFrom(targetHandleClass) } .filter { it.returnType == Void.TYPE || it.returnType == java.lang.Boolean.TYPE } .map { method -> method to scoreAttackMethod(method) } .sortedByDescending { it.second } .map { it.first } .toList() candidates.forEach { it.isAccessible = true } return candidates } private fun collectAllMethods(start: Class<*>): List { val methods = LinkedHashMap() var current: Class<*>? = start while (current != null) { current.declaredMethods.forEach { method -> methods.putIfAbsent(methodSignature(method), method) } current = current.superclass } start.methods.forEach { method -> methods.putIfAbsent(methodSignature(method), method) } return methods.values.toList() } private fun methodSignature(method: Method): String { val params = method.parameterTypes.joinToString(",") { it.name } return "${method.declaringClass.name}#${method.name}($params):${method.returnType.name}" } private fun scoreAttackMethod(method: Method): Int { var score = 0 val name = method.name val param = method.parameterTypes[0] val declaring = method.declaringClass.simpleName if (name == "attack") score += 100 if (name == "a") score += 80 if (param.simpleName == "Entity") score += 40 if (param.simpleName.contains("Entity")) score += 10 if (method.returnType == Void.TYPE) score += 10 if (method.returnType == java.lang.Boolean.TYPE) score += 8 if (declaring.contains("EntityHuman")) score += 25 if (declaring.contains("EntityPlayer")) score += 20 return score } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/AttackCooldownHeldItemIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleAttackCooldown import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.World import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.player.PlayerChangedWorldEvent import org.bukkit.event.player.PlayerItemHeldEvent import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerSwapHandItemsEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class AttackCooldownHeldItemIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } fun currentAttackSpeed(player: Player): Double { val attackSpeedAttribute = checkNotNull(XAttribute.ATTACK_SPEED.get()) { "Missing attack speed attribute type" } val attribute = player.getAttribute(attackSpeedAttribute) ?: error("Missing attack speed attribute") return attribute.baseValue } fun setModeset( player: Player, world: World, modeset: String, ) { val data = PlayerStorage.getPlayerData(player.uniqueId) data.setModesetForWorld(world.uid, modeset) PlayerStorage.setPlayerData(player.uniqueId, data) } fun fireJoin(player: Player) { Bukkit.getPluginManager().callEvent(PlayerJoinEvent(player, "test")) } fun switchHotbar( player: Player, from: Int, to: Int, ) { player.inventory.heldItemSlot = to Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, from, to)) } data class SpawnedPlayer( val fake: FakePlayer, val player: Player, ) fun spawnFake(world: World): SpawnedPlayer { lateinit var fake: FakePlayer lateinit var player: Player runSync { fake = FakePlayer(testPlugin) fake.spawn(Location(world, 0.0, 100.0, 0.0, 0f, 0f)) player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.inventory.clear() player.inventory.heldItemSlot = 0 player.activePotionEffects.forEach { player.removePotionEffect(it.type) } setModeset(player, world, "old") } return SpawnedPlayer(fake, player) } fun cleanup(spawnedPlayer: SpawnedPlayer) { runSync { spawnedPlayer.fake.removePlayer() } } suspend fun waitForPossibleDeferredWork() { delay(2 * 50L) } suspend fun withAttackCooldownConfig( genericAttackSpeed: Double, heldItemAttackSpeeds: Map, block: suspend () -> Unit, ) { val disabledModules = ocm.config.getStringList("disabled_modules") val alwaysEnabledModules = ocm.config.getStringList("always_enabled_modules") val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing 'modesets' section") val modesetSnapshot = modesetsSection.getKeys(false).associateWith { key -> ocm.config.getStringList("modesets.$key") } val genericSnapshot = ocm.config.get("disable-attack-cooldown.generic-attack-speed") val heldItemSnapshot = ocm.config.getConfigurationSection("disable-attack-cooldown.held-item-attack-speeds")?.getValues(false) ?: emptyMap() fun reloadAll() { ocm.saveConfig() Config.reload() ModuleLoader.toggleModules() module?.reload() } try { ocm.config.set("disable-attack-cooldown.generic-attack-speed", genericAttackSpeed) ocm.config.set("disable-attack-cooldown.held-item-attack-speeds", null) heldItemAttackSpeeds.forEach { (key, value) -> ocm.config.set("disable-attack-cooldown.held-item-attack-speeds.$key", value) } ocm.config.set("disabled_modules", disabledModules.filterNot { it == "disable-attack-cooldown" }) ocm.config.set("always_enabled_modules", alwaysEnabledModules.filterNot { it == "disable-attack-cooldown" }) val oldModeset = ocm.config.getStringList("modesets.old").toMutableList().apply { if (!contains("disable-attack-cooldown")) add("disable-attack-cooldown") } val newModeset = ocm.config.getStringList("modesets.new").toMutableList().apply { remove("disable-attack-cooldown") } ocm.config.set("modesets.old", oldModeset) ocm.config.set("modesets.new", newModeset) reloadAll() block() } finally { ocm.config.set("disabled_modules", disabledModules) ocm.config.set("always_enabled_modules", alwaysEnabledModules) modesetSnapshot.forEach { (key, list) -> ocm.config.set("modesets.$key", list) } ocm.config.set("disable-attack-cooldown.generic-attack-speed", genericSnapshot) ocm.config.set("disable-attack-cooldown.held-item-attack-speeds", null) heldItemSnapshot.forEach { (key, value) -> ocm.config.set("disable-attack-cooldown.held-item-attack-speeds.$key", value) } reloadAll() } } test("applies configured held-item attack speeds and falls back to the generic value on hotbar switch") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItem(0, ItemStack(Material.IRON_SWORD)) spawned.player.inventory.setItem(1, ItemStack(Material.STICK)) spawned.player.inventory.heldItemSlot = 0 fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { switchHotbar(spawned.player, from = 0, to = 1) } runSync { currentAttackSpeed(spawned.player) } shouldBe (12.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("materials without an explicit held-item entry use disable-attack-cooldown.generic-attack-speed") { withAttackCooldownConfig( genericAttackSpeed = 13.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItemInMainHand(ItemStack(Material.STICK)) fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (13.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("world and modeset transitions restore vanilla 4.0 when disabled and reapply the held-item target when re-enabled") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val otherWorld = checkNotNull(Bukkit.getWorld("world_nether")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) setModeset(spawned.player, world, "old") setModeset(spawned.player, otherWorld, "new") fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { setModeset(spawned.player, world, "new") module?.onModesetChange(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (4.0 plusOrMinus 0.01) runSync { setModeset(spawned.player, world, "old") module?.onModesetChange(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { spawned.player.teleport(Location(otherWorld, 0.0, 100.0, 0.0, 0f, 0f)) Bukkit.getPluginManager().callEvent(PlayerChangedWorldEvent(spawned.player, world)) } runSync { currentAttackSpeed(spawned.player) } shouldBe (4.0 plusOrMinus 0.01) runSync { spawned.player.teleport(Location(world, 0.0, 100.0, 0.0, 0f, 0f)) Bukkit.getPluginManager().callEvent(PlayerChangedWorldEvent(spawned.player, otherWorld)) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("user-added material keys are accepted when the running server recognises the material") { val material = Material.matchMaterial("MACE") ?: return@test withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf(material.name to 7.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItemInMainHand(ItemStack(material)) fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (7.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("main-hand attack speed follows hand swaps and uses the newly held item") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItemInMainHand(ItemStack(Material.STICK)) spawned.player.inventory.setItemInOffHand(ItemStack(Material.IRON_SWORD)) fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (12.0 plusOrMinus 0.01) runSync { val swap = PlayerSwapHandItemsEvent( spawned.player, spawned.player.inventory.itemInMainHand, spawned.player.inventory.itemInOffHand, ) Bukkit.getPluginManager().callEvent(swap) spawned.player.inventory.setItemInMainHand(swap.offHandItem) spawned.player.inventory.setItemInOffHand(swap.mainHandItem) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("cancelled hotbar changes keep attack speed tied to the actually held item") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) val canceller = object : Listener { @EventHandler(priority = EventPriority.LOWEST) fun onHeld(event: PlayerItemHeldEvent) { if (event.player.uniqueId == spawned.player.uniqueId) { event.isCancelled = true } } } try { runSync { Bukkit.getPluginManager().registerEvents(canceller, testPlugin) spawned.player.inventory.setItem(0, ItemStack(Material.IRON_SWORD)) spawned.player.inventory.setItem(1, ItemStack(Material.STICK)) spawned.player.inventory.heldItemSlot = 0 fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { val event = PlayerItemHeldEvent(spawned.player, 0, 1) Bukkit.getPluginManager().callEvent(event) } runSync { spawned.player.inventory.heldItemSlot } shouldBe 0 runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) } finally { runSync { HandlerList.unregisterAll(canceller) } cleanup(spawned) } } } test("cancelled hand swaps keep attack speed tied to the actual main-hand item") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) val canceller = object : Listener { @EventHandler(priority = EventPriority.LOWEST) fun onSwap(event: PlayerSwapHandItemsEvent) { if (event.player.uniqueId == spawned.player.uniqueId) { event.isCancelled = true } } } try { runSync { Bukkit.getPluginManager().registerEvents(canceller, testPlugin) spawned.player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) spawned.player.inventory.setItemInOffHand(ItemStack(Material.STICK)) fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { val event = PlayerSwapHandItemsEvent( spawned.player, spawned.player.inventory.itemInMainHand, spawned.player.inventory.itemInOffHand, ) Bukkit.getPluginManager().callEvent(event) } runSync { spawned.player.inventory.itemInMainHand.type } shouldBe Material.IRON_SWORD runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) } finally { runSync { HandlerList.unregisterAll(canceller) } cleanup(spawned) } } } test("later inventory changes after a hotbar event do not trigger deferred attack-speed reconciliation") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItem(0, ItemStack(Material.IRON_SWORD)) spawned.player.inventory.setItem(1, ItemStack(Material.STICK)) spawned.player.inventory.heldItemSlot = 0 fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) runSync { val event = PlayerItemHeldEvent(spawned.player, 0, 1) Bukkit.getPluginManager().callEvent(event) spawned.player.inventory.heldItemSlot = 1 spawned.player.inventory.heldItemSlot = 0 } waitForPossibleDeferredWork() runSync { spawned.player.inventory.heldItemSlot } shouldBe 0 runSync { spawned.player.inventory.itemInMainHand.type } shouldBe Material.IRON_SWORD runSync { currentAttackSpeed(spawned.player) } shouldBe (12.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } test("unchanged post-swap inventory keeps the swap-applied attack speed without deferred re-checking") { withAttackCooldownConfig( genericAttackSpeed = 12.0, heldItemAttackSpeeds = mapOf("IRON_SWORD" to 19.0), ) { val world = checkNotNull(Bukkit.getWorld("world")) val spawned = spawnFake(world) try { runSync { spawned.player.inventory.setItemInMainHand(ItemStack(Material.STICK)) spawned.player.inventory.setItemInOffHand(ItemStack(Material.IRON_SWORD)) fireJoin(spawned.player) } runSync { currentAttackSpeed(spawned.player) } shouldBe (12.0 plusOrMinus 0.01) runSync { val event = PlayerSwapHandItemsEvent( spawned.player, spawned.player.inventory.itemInMainHand, spawned.player.inventory.itemInOffHand, ) Bukkit.getPluginManager().callEvent(event) spawned.player.inventory.setItemInMainHand(event.offHandItem) spawned.player.inventory.setItemInOffHand(event.mainHandItem) } waitForPossibleDeferredWork() runSync { spawned.player.inventory.itemInMainHand.type } shouldBe Material.IRON_SWORD runSync { currentAttackSpeed(spawned.player) } shouldBe (19.0 plusOrMinus 0.01) } finally { cleanup(spawned) } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/AttackCooldownTrackerIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeGreaterThanOrEqual import io.kotest.matchers.doubles.shouldBeLessThanOrEqual import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.damage.AttackCooldownTracker import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class AttackCooldownTrackerIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } extensions(MainThreadDispatcherExtension(testPlugin)) test("attack cooldown tracking is only active where required") { val isModern = Reflector.versionIsNewerOrEqualTo(1, 16, 0) val uuid = runSync { val world = Bukkit.getWorld("world") ?: error("world not loaded") val location = Location(world, 0.0, 120.0, 0.0, 0f, 0f) val fp = FakePlayer(testPlugin) fp.spawn(location) fp.uuid } try { // Let at least one tick elapse so any scheduled tracker has a chance to populate. delay(2 * 50L) val last = runSync { AttackCooldownTracker.getLastCooldown(uuid) } if (isModern) { last shouldBe null } else { val value = (last ?: error("Expected a cached cooldown value on legacy servers")).toDouble() value.shouldBeGreaterThanOrEqual(0.0) value.shouldBeLessThanOrEqual(1.0) } } finally { // Ensure we remove the fake player regardless of assertions. runSync { val player = Bukkit.getPlayer(uuid) player?.let { // FakePlayer removal fires a quit event; this is enough to validate map cleanup on legacy servers. it.kickPlayer("test") } } delay(2 * 50L) // Legacy servers: tracker should remove on quit. Modern servers: tracker should remain inactive and return null. val afterQuit = runSync { AttackCooldownTracker.getLastCooldown(uuid) } afterQuit shouldBe null } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/AttackRangeIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeLessThan import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleAttackRange import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.EntityType import org.bukkit.entity.Player import org.bukkit.entity.Zombie import org.bukkit.event.player.PlayerDropItemEvent import org.bukkit.event.player.PlayerItemHeldEvent import org.bukkit.event.player.PlayerSwapHandItemsEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable /** * Behavioural reach tests for the attack-range module. * * The module extends melee reach; we assert a hit just outside vanilla reach succeeds * when enabled, but the same swing misses when disabled. A control swing inside vanilla * reach must hit in both cases. */ @OptIn(ExperimentalKotest::class) class AttackRangeIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val attackRangeModule = ModuleLoader.getModules().filterIsInstance().firstOrNull() val applyMethod = attackRangeModule?.javaClass?.getDeclaredMethod("applyToHeld", Player::class.java)?.apply { isAccessible = true } fun hasAttackRange(stack: ItemStack?): Boolean = try { if (stack == null) return false val dctClass = Class.forName("io.papermc.paper.datacomponent.DataComponentTypes") val typeField = dctClass.getField("ATTACK_RANGE") val type = typeField.get(null) val baseTypeClass = Class.forName("io.papermc.paper.datacomponent.DataComponentType") val getter = ItemStack::class.java.getMethod("getData", baseTypeClass) getter.invoke(stack, type) != null } catch (t: Throwable) { false } extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod( testPlugin, Callable { action() null }, ).get() } } suspend fun withModuleState( enabled: Boolean, maxRange: Double = 6.0, margin: Double = 0.1, block: suspend () -> Unit, ) { // Snapshot val disabledOrig = ocm.config.getStringList("disabled_modules").toMutableList() val alwaysOrig = ocm.config.getStringList("always_enabled_modules").toMutableList() val maxOrig = ocm.config.getDouble("attack-range.max-range") val marginOrig = ocm.config.getDouble("attack-range.hitbox-margin") fun cachedSet(field: String): MutableSet { val f = kernitus.plugin.OldCombatMechanics.utilities.Config::class.java.getDeclaredField(field) f.isAccessible = true @Suppress("UNCHECKED_CAST") return f.get(null) as MutableSet } val cachedDisabledOrig = cachedSet("disabledModules").toSet() val cachedAlwaysOrig = cachedSet("alwaysEnabledModules").toSet() try { // Update lists val disabled = disabledOrig.toMutableList() val always = alwaysOrig.toMutableList() if (enabled) { disabled.remove("attack-range") if (!always.contains("attack-range")) always.add("attack-range") } else { if (!disabled.contains("attack-range")) disabled.add("attack-range") always.remove("attack-range") } ocm.config.set("disabled_modules", disabled) ocm.config.set("always_enabled_modules", always) cachedSet("disabledModules").apply { clear() addAll(disabled.map { it.lowercase() }) } cachedSet("alwaysEnabledModules").apply { clear() addAll(always.map { it.lowercase() }) } // Config tweaks ocm.config.set("attack-range.max-range", maxRange) ocm.config.set("attack-range.hitbox-margin", margin) attackRangeModule?.reload() ModuleLoader.toggleModules() block() } finally { // Restore ocm.config.set("disabled_modules", disabledOrig) ocm.config.set("always_enabled_modules", alwaysOrig) ocm.config.set("attack-range.max-range", maxOrig) ocm.config.set("attack-range.hitbox-margin", marginOrig) cachedSet("disabledModules").apply { clear() addAll(cachedDisabledOrig) } cachedSet("alwaysEnabledModules").apply { clear() addAll(cachedAlwaysOrig) } attackRangeModule?.reload() ModuleLoader.toggleModules() } } data class Actors( val fake: FakePlayer, val player: Player, val zombie: Zombie, ) fun spawnActors(): Actors { lateinit var fake: FakePlayer lateinit var player: Player lateinit var zombie: Zombie runSync { val world = checkNotNull(Bukkit.getWorld("world")) fake = FakePlayer(testPlugin) fake.spawn(Location(world, 0.0, 100.0, 0.0)) player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.inventory.clear() player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) zombie = world.spawnEntity(Location(world, 0.0, 100.0, 0.0), EntityType.ZOMBIE) as Zombie zombie.health = zombie.maxHealth } return Actors(fake, player, zombie) } fun cleanup(actors: Actors) { runSync { actors.zombie.remove() } runSync { actors.fake.removePlayer() } } fun faceEntity( player: Player, target: org.bukkit.entity.Entity, ) { val eye = player.eyeLocation val tgt = target.location.clone().add(0.0, target.height / 2.0, 0.0) val dir = tgt.toVector().subtract(eye.toVector()) val yaw = Math.toDegrees(Math.atan2(-dir.x, dir.z)).toFloat() val pitch = Math.toDegrees(-Math.atan2(dir.y, Math.hypot(dir.x, dir.z))).toFloat() val newLoc = player.location.clone() newLoc.yaw = yaw newLoc.pitch = pitch player.teleport(newLoc) } fun swingAt( zombie: Zombie, player: Player, ) { runSync { faceEntity(player, zombie) player.attack(zombie) } } test("extended reach hits just outside vanilla range when module enabled (Paper 1.21.11+)") { if (!Reflector.versionIsNewerOrEqualTo(1, 21, 11)) return@test if (attackRangeModule == null) return@test withModuleState(enabled = true, maxRange = 5.0, margin = 0.1) { val actors = spawnActors() val (_, player, zombie) = actors runSync { applyMethod?.invoke(attackRangeModule, player) } runSync { zombie.noDamageTicks = 0 zombie.health = zombie.maxHealth zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } var startHealth = zombie.health swingAt(zombie, player) runSync { zombie.health shouldBeLessThan startHealth } cleanup(actors) } } test("reach boost is removed after disabling while holding the same item (Paper 1.21.11+)") { if (!Reflector.versionIsNewerOrEqualTo(1, 21, 11)) return@test if (attackRangeModule == null) return@test val actors = spawnActors() val (_, player, zombie) = actors withModuleState(enabled = true, maxRange = 5.5) { runSync { applyMethod?.invoke(attackRangeModule, player) } runSync { zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } var start = zombie.health swingAt(zombie, player) // should hit with extended reach runSync { zombie.health shouldBeLessThan start } withModuleState(enabled = false) { runSync { // trigger hand re-evaluation Bukkit.getPluginManager().callEvent( PlayerItemHeldEvent(player, player.inventory.heldItemSlot, player.inventory.heldItemSlot), ) zombie.health = zombie.maxHealth zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } start = zombie.health swingAt(zombie, player) // should now miss runSync { zombie.health shouldBe start } } } cleanup(actors) } test("dropped items do not retain reach boost (Paper 1.21.11+)") { if (!Reflector.versionIsNewerOrEqualTo(1, 21, 11)) return@test if (attackRangeModule == null) return@test val actors = spawnActors() val (_, player, zombie) = actors withModuleState(enabled = true) { runSync { applyMethod?.invoke(attackRangeModule, player) } runSync { zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } var start = zombie.health swingAt(zombie, player) // extended reach hit runSync { zombie.health shouldBeLessThan start } val dropped: ItemStack = run { var item: ItemStack? = null runSync { val drop = player.world.dropItem(player.location, player.inventory.itemInMainHand.clone()) Bukkit.getPluginManager().callEvent(PlayerDropItemEvent(player, drop)) item = drop.itemStack drop.remove() } item!! } withModuleState(enabled = false) { runSync { player.inventory.setItemInMainHand(dropped) Bukkit.getPluginManager().callEvent( PlayerItemHeldEvent(player, player.inventory.heldItemSlot, player.inventory.heldItemSlot), ) zombie.health = zombie.maxHealth zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } start = zombie.health swingAt(zombie, player) // should miss because drop cleaned component runSync { zombie.health shouldBe start } } } cleanup(actors) } test("extended reach does not apply when module disabled; close swing still hits (Paper 1.21.11+)") { if (!Reflector.versionIsNewerOrEqualTo(1, 21, 11)) return@test if (attackRangeModule == null) return@test withModuleState(enabled = false) { val actors = spawnActors() val (_, player, zombie) = actors // Far swing should miss when module disabled runSync { zombie.noDamageTicks = 0 zombie.health = zombie.maxHealth zombie.teleport(player.location.clone().add(0.0, 0.0, 5.5)) } var healthAfterFar = zombie.health swingAt(zombie, player) runSync { healthAfterFar = zombie.health } // Control: move inside vanilla reach and ensure it hits runSync { zombie.noDamageTicks = 0 zombie.teleport(player.location.clone().add(0.0, 0.0, 2.5)) } swingAt(zombie, player) runSync { zombie.health shouldBeLessThan healthAfterFar } cleanup(actors) } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/AttributeModifierCompat.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage import org.bukkit.attribute.AttributeModifier import org.bukkit.inventory.EquipmentSlot import org.bukkit.attribute.Attribute import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.ItemMeta import com.google.common.collect.HashMultimap import com.google.common.collect.Multimap import java.util.UUID fun createAttributeModifier( name: String, amount: Double, operation: AttributeModifier.Operation, slot: EquipmentSlot? = null, uuid: UUID = UUID.randomUUID() ): AttributeModifier { // Use the most specific constructor available at runtime. if (slot != null) { try { @Suppress("DEPRECATION") return AttributeModifier(uuid, name, amount, operation, slot) } catch (e: NoSuchMethodError) { // Fall back to the older signatures below. } } try { @Suppress("DEPRECATION") return AttributeModifier(uuid, name, amount, operation) } catch (e: NoSuchMethodError) { @Suppress("DEPRECATION") return AttributeModifier(name, amount, operation) } } fun addAttributeModifierCompat(meta: ItemMeta, attribute: Attribute, modifier: AttributeModifier) { try { meta.addAttributeModifier(attribute, modifier) return } catch (e: NoSuchMethodError) { // Older APIs do not expose addAttributeModifier on ItemMeta. } try { val multimap = HashMultimap.create() multimap.put(attribute, modifier) meta.setAttributeModifiers(multimap) } catch (e: NoSuchMethodError) { // Attribute modifiers are not supported on this API version. } } fun getDefaultAttributeModifiersCompat( item: ItemStack, slot: EquipmentSlot, attribute: Attribute ): Collection { try { return item.type.getDefaultAttributeModifiers(slot)[attribute] ?: emptySet() } catch (e: NoSuchMethodError) { // Fall back to older Material APIs if present. } val modifiers = try { val method = item.type.javaClass.getMethod("getAttributeModifiers", EquipmentSlot::class.java) @Suppress("UNCHECKED_CAST") val multimap = method.invoke(item.type, slot) as Multimap multimap.get(attribute) ?: emptySet() } catch (e: Exception) { emptySet() } if (modifiers.isNotEmpty()) { return modifiers } val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() if (attackDamageAttribute != null && attribute == attackDamageAttribute && slot == EquipmentSlot.HAND) { val fallbackDamage = NewWeaponDamage.getDamageOrNull(item.type) ?: return emptySet() val amount = fallbackDamage.toDouble() - 1.0 val fallbackModifier = createAttributeModifier( name = "ocm-fallback-damage", amount = amount, operation = AttributeModifier.Operation.ADD_NUMBER, slot = slot ) return setOf(fallbackModifier) } return emptySet() } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/ChorusFruitIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.booleans.shouldBeTrue import io.kotest.matchers.doubles.shouldBeLessThanOrEqual import kernitus.plugin.OldCombatMechanics.module.ModuleChorusFruit import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.block.BlockFace import org.bukkit.entity.Player import org.bukkit.event.player.PlayerTeleportEvent import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class ChorusFruitIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val chorusModule = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleChorusFruit not registered") extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun preparePlatform() { runSync { val world = checkNotNull(Bukkit.getWorld("world")) // Solid floor at y=100 and clear air above it in a 25x25 area around the origin for (x in -12..12) { for (z in -12..12) { world.getBlockAt(x, 100, z).type = Material.STONE for (y in 101..105) { world.getBlockAt(x, y, z).type = Material.AIR } } } } } fun clearPlatform() { runSync { val world = checkNotNull(Bukkit.getWorld("world")) for (x in -12..12) { for (z in -12..12) { for (y in 99..105) { world.getBlockAt(x, y, z).type = Material.AIR } } } } } suspend fun TestScope.withChorusConfig(distance: Double, block: suspend TestScope.() -> Unit) { val enabled = ocm.config.getBoolean("chorus-fruit.enabled") val maxDistance = ocm.config.getDouble("chorus-fruit.max-teleportation-distance") val preventEating = ocm.config.getBoolean("chorus-fruit.prevent-eating") val hungerValue = ocm.config.getInt("chorus-fruit.hunger-value") val saturationValue = ocm.config.getDouble("chorus-fruit.saturation-value") try { ocm.config.set("chorus-fruit.enabled", true) ocm.config.set("chorus-fruit.max-teleportation-distance", distance) ocm.config.set("chorus-fruit.prevent-eating", false) ocm.config.set("chorus-fruit.hunger-value", hungerValue) ocm.config.set("chorus-fruit.saturation-value", saturationValue) chorusModule.reload() ModuleLoader.toggleModules() block() } finally { clearPlatform() ocm.config.set("chorus-fruit.enabled", enabled) ocm.config.set("chorus-fruit.max-teleportation-distance", maxDistance) ocm.config.set("chorus-fruit.prevent-eating", preventEating) ocm.config.set("chorus-fruit.hunger-value", hungerValue) ocm.config.set("chorus-fruit.saturation-value", saturationValue) chorusModule.reload() ModuleLoader.toggleModules() } } fun Location.isSafe(): Boolean { val feet = block val head = feet.getRelative(BlockFace.UP) val below = feet.getRelative(BlockFace.DOWN) val legacy = !kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector.versionIsNewerOrEqualTo(1, 13, 0) val feetPassable = if (legacy) !feet.type.isSolid else feet.isPassable val headPassable = if (legacy) !head.type.isSolid else head.isPassable return feetPassable && headPassable && below.type.isSolid } suspend fun withFakePlayer(origin: Location, block: suspend (Player) -> Unit) { lateinit var fake: FakePlayer lateinit var player: Player runSync { fake = FakePlayer(testPlugin) fake.spawn(origin) player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val data = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) data.setModesetForWorld(player.world.uid, "old") kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, data) } try { block(player) } finally { runSync { fake.removePlayer() } } } test("chorus fruit custom distance teleports to a safe spot") { preparePlatform() withChorusConfig(distance = 1.0) { val origin = Location(checkNotNull(Bukkit.getWorld("world")), 0.5, 101.0, 0.5) withFakePlayer(origin) { player -> var result: Location? = null runSync { val event = PlayerTeleportEvent( player, player.location, player.location.clone(), PlayerTeleportEvent.TeleportCause.CHORUS_FRUIT ) Bukkit.getPluginManager().callEvent(event) result = event.to } val target = result ?: error("Teleport target was null") // Horizontal displacement should respect the configured radius kotlin.math.abs(target.x - origin.x) shouldBeLessThanOrEqual 1.0 kotlin.math.abs(target.z - origin.z) shouldBeLessThanOrEqual 1.0 // Y stays within the search band (clamped to world height) kotlin.math.abs(target.y - origin.y) shouldBeLessThanOrEqual 1.0 target.isSafe().shouldBeTrue() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/ConfigMigrationIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.collections.shouldContain import io.kotest.matchers.collections.shouldNotContain import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.Config import org.bukkit.Bukkit import org.bukkit.configuration.file.YamlConfiguration import org.bukkit.plugin.java.JavaPlugin import java.io.File import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class ConfigMigrationIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun withConfigFile(block: () -> Unit) { val dataFolder = ocm.dataFolder val configFile = File(dataFolder, "config.yml") val backupFile = File(dataFolder, "config-backup.yml") val originalConfig = if (configFile.exists()) configFile.readText() else "" val hadBackup = backupFile.exists() val originalBackup = if (hadBackup) backupFile.readText() else null try { block() } finally { if (!configFile.parentFile.exists()) { configFile.parentFile.mkdirs() } configFile.writeText(originalConfig) if (hadBackup) { backupFile.writeText(originalBackup ?: "") } else if (backupFile.exists()) { backupFile.delete() } ocm.reloadConfig() Config.reload() } } test("config upgrade migrates module buckets and preserves modesets") { runSync { withConfigFile { val configFile = File(ocm.dataFolder, "config.yml") val oldConfig = YamlConfiguration.loadConfiguration(configFile) val currentVersion = oldConfig.getInt("config-version") val oldVersion = currentVersion - 1 oldConfig.set("config-version", oldVersion) oldConfig.set("force-below-1-18-1-config-upgrade", true) oldConfig.set( "modesets", mapOf( "custom" to listOf("disable-offhand"), "alt" to listOf("old-golden-apples") ) ) oldConfig.set("worlds.world", listOf("custom", "alt")) oldConfig.set("disable-offhand.enabled", false) oldConfig.set("old-golden-apples.enabled", true) oldConfig.set("old-potion-effects.enabled", true) oldConfig.set("disable-attack-cooldown.enabled", false) oldConfig.save(configFile) Config.reload() val upgradedConfig = ocm.config upgradedConfig.getInt("config-version") shouldBe currentVersion val alwaysEnabled = upgradedConfig.getStringList("always_enabled_modules") val disabledModules = upgradedConfig.getStringList("disabled_modules") alwaysEnabled.shouldContain("old-potion-effects") disabledModules.shouldContain("disable-offhand") disabledModules.shouldContain("disable-attack-cooldown") disabledModules.shouldNotContain("old-golden-apples") val modesetsSection = upgradedConfig.getConfigurationSection("modesets") ?: error("Modesets section missing after migration") modesetsSection.getKeys(false).shouldContain("custom") modesetsSection.getKeys(false).shouldContain("alt") upgradedConfig.getStringList("modesets.custom").shouldNotContain("disable-offhand") upgradedConfig.getStringList("modesets.alt").shouldContain("old-golden-apples") upgradedConfig.getStringList("worlds.world") shouldBe listOf("custom", "alt") } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/ConsumableComponentIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleSwordBlocking import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.block.BlockFace import org.bukkit.entity.Player import org.bukkit.event.block.Action import org.bukkit.event.entity.PlayerDeathEvent import org.bukkit.event.inventory.ClickType import org.bukkit.event.inventory.InventoryAction import org.bukkit.event.inventory.InventoryClickEvent import org.bukkit.event.inventory.InventoryDragEvent import org.bukkit.event.inventory.InventoryType import org.bukkit.event.player.PlayerChangedWorldEvent import org.bukkit.event.player.PlayerDropItemEvent import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.event.player.PlayerItemHeldEvent import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerQuitEvent import org.bukkit.event.player.PlayerSwapHandItemsEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.Optional import java.util.UUID import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class ConsumableComponentIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val swordBlocking = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModuleSwordBlocking not registered") extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod(testPlugin, Callable { action() }) .get() } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } fun rightClickMainHand(player: Player) { runSync { val event = PlayerInteractEvent( player, Action.RIGHT_CLICK_AIR, player.inventory.itemInMainHand, null, BlockFace.SELF, EquipmentSlot.HAND, ) Bukkit.getPluginManager().callEvent(event) } } fun paperDataComponentApiPresent(): Boolean = try { Class.forName("io.papermc.paper.datacomponent.DataComponentTypes") true } catch (_: Throwable) { false } fun paperConsumablePathAvailable(): Boolean { if (!paperDataComponentApiPresent()) return false val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: return false return try { val supportedField = ModuleSwordBlocking::class.java.getDeclaredField("paperSupported") supportedField.isAccessible = true val adapterField = ModuleSwordBlocking::class.java.getDeclaredField("paperAdapter") adapterField.isAccessible = true supportedField.getBoolean(module) && adapterField.get(module) != null } catch (_: Throwable) { false } } fun packetEventsClass(name: String): Class<*> = Class.forName(name, true, ocm.javaClass.classLoader) fun packetEventsClientVersionClass(): Class<*> = packetEventsClass("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.player.ClientVersion") fun packetEventsUserClass(): Class<*> = packetEventsClass("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.player.User") fun packetEventsUserProfileClass(): Class<*> = packetEventsClass("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.player.UserProfile") fun packetEventsConnectionStateClass(): Class<*> = packetEventsClass("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.ConnectionState") fun packetEventsApi(): Any { val packetEventsClass = packetEventsClass("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.PacketEvents") return packetEventsClass.getMethod("getAPI").invoke(null) ?: error("PacketEvents API not available") } fun packetEventsPlayerManager(): Any { val api = packetEventsApi() val method = api.javaClass.getDeclaredMethod("getPlayerManager") method.isAccessible = true return method.invoke(api) ?: error("PacketEvents PlayerManager not available") } fun packetEventsProtocolManager(): Any { val api = packetEventsApi() val method = api.javaClass.getDeclaredMethod("getProtocolManager") method.isAccessible = true return method.invoke(api) ?: error("PacketEvents ProtocolManager not available") } suspend fun requirePacketEventsUser(player: Player): Any { val playerManager = packetEventsPlayerManager() val getUserMethod = playerManager.javaClass.getDeclaredMethod("getUser", Any::class.java) getUserMethod.isAccessible = true repeat(10) { val user = runSync { getUserMethod.invoke(playerManager, player) } if (user != null) return user delayTicks(1) } val getChannelMethod = playerManager.javaClass.getDeclaredMethod("getChannel", Any::class.java) getChannelMethod.isAccessible = true val channel = runSync { getChannelMethod.invoke(playerManager, player) } ?: error("PacketEvents channel missing for ${player.name}") val protocolManager = packetEventsProtocolManager() val setChannel = protocolManager.javaClass.getMethod("setChannel", UUID::class.java, Any::class.java) runSync { setChannel.invoke(protocolManager, player.uniqueId, channel) } val connectionStateClass = packetEventsConnectionStateClass() @Suppress("UNCHECKED_CAST") val connectionStateEnum = connectionStateClass as Class> val playState = java.lang.Enum.valueOf(connectionStateEnum, "PLAY") val profileClass = packetEventsUserProfileClass() val profile = profileClass .getConstructor(UUID::class.java, String::class.java) .newInstance(player.uniqueId, player.name) val clientVersionClass = packetEventsClientVersionClass() @Suppress("UNCHECKED_CAST") val clientVersionEnum = clientVersionClass as Class> val defaultVersion = java.lang.Enum.valueOf(clientVersionEnum, "V_1_21_11") val userClass = packetEventsUserClass() val user = userClass .getConstructor(Any::class.java, connectionStateClass, clientVersionClass, profileClass) .newInstance(channel, playState, defaultVersion, profile) val setUser = protocolManager.javaClass.getMethod("setUser", Any::class.java, userClass) runSync { setUser.invoke(protocolManager, channel, user) } return user } fun packetEventsClientVersion(versionName: String): Any { val versionClass = packetEventsClientVersionClass() @Suppress("UNCHECKED_CAST") val enumClass = versionClass as Class> return java.lang.Enum.valueOf(enumClass, versionName) } fun unknownPacketEventsClientVersionName(): String? { val versionClass = packetEventsClientVersionClass() @Suppress("UNCHECKED_CAST") val enumClass = versionClass as Class> val names = enumClass.enumConstants.map { it.name } return when { names.contains("UNKNOWN") -> "UNKNOWN" names.contains("HIGHER_THAN_SUPPORTED_VERSIONS") -> "HIGHER_THAN_SUPPORTED_VERSIONS" else -> null } } suspend fun withPacketEventsClientVersion( player: Player, versionName: String, block: suspend () -> Unit, ) { val user = requirePacketEventsUser(player) val versionClass = packetEventsClientVersionClass() val getVersion = user.javaClass.getDeclaredMethod("getClientVersion") val setVersion = user.javaClass.getDeclaredMethod("setClientVersion", versionClass) getVersion.isAccessible = true setVersion.isAccessible = true val original = runSync { getVersion.invoke(user) } val target = packetEventsClientVersion(versionName) runSync { setVersion.invoke(user, target) } try { block() } finally { if (original != null) { runSync { setVersion.invoke(user, original) } } } } fun nmsItemStack(stack: ItemStack?): Any? { if (stack == null) return null var handle: Any? = null try { var type: Class<*>? = stack.javaClass while (type != null && type != Any::class.java) { val field = try { type.getDeclaredField("handle") } catch (_: NoSuchFieldException) { type = type.superclass continue } field.isAccessible = true handle = runCatching { field.get(stack) }.getOrNull() break } } catch (_: Throwable) { handle = null } if (handle != null) return handle return try { val craftItemStack = Class.forName("org.bukkit.craftbukkit.inventory.CraftItemStack") val asNmsCopy = craftItemStack.getMethod("asNMSCopy", ItemStack::class.java) asNmsCopy.invoke(null, stack) } catch (t: Throwable) { throw IllegalStateException( "Failed to obtain NMS ItemStack (${t::class.java.simpleName}: ${t.message})", t, ) } } fun craftMirrorStack(type: Material): ItemStack { val craftItemStack = Class.forName("org.bukkit.craftbukkit.inventory.CraftItemStack") val nmsItemStackClass = Class.forName("net.minecraft.world.item.ItemStack") val asNmsCopy = craftItemStack.getMethod("asNMSCopy", ItemStack::class.java) val asCraftMirror = craftItemStack.getMethod("asCraftMirror", nmsItemStackClass) val nms = asNmsCopy.invoke(null, ItemStack(type)) return asCraftMirror.invoke(null, nms) as ItemStack } fun consumablePatchEntry(stack: ItemStack?): Optional<*>? { val nmsStack = nmsItemStack(stack) ?: return null return try { val patch = nmsStack.javaClass.getMethod("getComponentsPatch").invoke(nmsStack) ?: return null val dataComponentType = Class.forName("net.minecraft.core.component.DataComponentType") val dataComponents = Class.forName("net.minecraft.core.component.DataComponents") val consumableType = dataComponents.getField("CONSUMABLE").get(null) val getMethod = patch.javaClass.getMethod("get", dataComponentType) getMethod.invoke(patch, consumableType) as? Optional<*> } catch (t: Throwable) { throw IllegalStateException( "Failed to inspect data component patch (${t::class.java.simpleName}: ${t.message})", t, ) } } fun hasConsumableRemoval(stack: ItemStack?): Boolean { val entry = consumablePatchEntry(stack) ?: return false return !entry.isPresent } fun nmsConsumableType(): Any = Class.forName("net.minecraft.core.component.DataComponents").getField("CONSUMABLE").get(null) fun nmsConsumableComponent(): Any { val nmsConsumable = Class.forName("net.minecraft.world.item.component.Consumable") val builder = nmsConsumable.getMethod("builder").invoke(null) val nmsUseAnim = Class.forName("net.minecraft.world.item.ItemUseAnimation") val blockAnim = nmsUseAnim.getField("BLOCK").get(null) val withSeconds = builder.javaClass.getMethod("consumeSeconds", Float::class.javaPrimitiveType).invoke(builder, 1.6f) val withAnim = withSeconds.javaClass.getMethod("animation", nmsUseAnim).invoke(withSeconds, blockAnim) return withAnim.javaClass.getMethod("build").invoke(withAnim) } fun hasConsumableComponent(stack: ItemStack?): Boolean { val nmsStack = nmsItemStack(stack) ?: return false return try { val dataComponentType = Class.forName("net.minecraft.core.component.DataComponentType") val consumableType = nmsConsumableType() val hasMethod = nmsStack.javaClass.getMethod("has", dataComponentType) val result = hasMethod.invoke(nmsStack, consumableType) result is Boolean && result } catch (_: Throwable) { false } } fun applyConsumableComponent(stack: ItemStack?) { val nmsStack = nmsItemStack(stack) ?: return try { val dataComponentType = Class.forName("net.minecraft.core.component.DataComponentType") val consumableType = nmsConsumableType() val consumableComponent = nmsConsumableComponent() val setMethod = nmsStack.javaClass.methods.firstOrNull { m -> m.name == "set" && m.parameterCount == 2 && m.parameterTypes[0] == dataComponentType } ?: error("NMS ItemStack#set(DataComponentType, value) not found") setMethod.invoke(nmsStack, consumableType, consumableComponent) } catch (t: Throwable) { throw IllegalStateException( "Failed to apply NMS consumable component (${t::class.java.simpleName}: ${t.message})", t, ) } } fun assertNoConsumableRemoval( stack: ItemStack?, label: String, ) { val entry = consumablePatchEntry(stack) if (entry != null && !entry.isPresent) { error("$label gained !minecraft:consumable") } } fun setModeset( player: Player, modeset: String?, ) { val data = getPlayerData(player.uniqueId) val worldId = player.world.uid if (modeset == null) { data.modesetByWorld.remove(worldId) } else { data.setModesetForWorld(worldId, modeset) } setPlayerData(player.uniqueId, data) } fun syntheticPlayerDeathEvent( player: Player, drops: MutableList, ): PlayerDeathEvent { for (ctor in PlayerDeathEvent::class.java.constructors) { val args = arrayOfNulls(ctor.parameterCount) var supported = true for ((index, paramType) in ctor.parameterTypes.withIndex()) { val value: Any? = when { Player::class.java.isAssignableFrom(paramType) -> { player } MutableList::class.java.isAssignableFrom(paramType) || List::class.java.isAssignableFrom(paramType) -> { drops } paramType == Int::class.javaPrimitiveType || paramType == Int::class.java -> { 0 } paramType == Boolean::class.javaPrimitiveType || paramType == Boolean::class.java -> { false } paramType == String::class.java -> { "" } else -> { if (paramType.isPrimitive) { supported = false null } else { null } } } if (!supported) break args[index] = value } if (!supported) continue val instance = runCatching { ctor.newInstance(*args) }.getOrNull() ?: continue if (instance is PlayerDeathEvent) { return instance } } error("Failed to create PlayerDeathEvent reflectively") } fun snapshotSection(path: String): Any? { val section = ocm.config.getConfigurationSection(path) return section?.getValues(false) ?: ocm.config.get(path) } fun restoreSection( path: String, value: Any?, ) { ocm.config.set(path, null) when (value) { null -> { Unit } is Map<*, *> -> { @Suppress("UNCHECKED_CAST") ocm.config.createSection(path, value as Map) } else -> { ocm.config.set(path, value) } } } suspend fun withWorldModesets( worldModesets: List, block: suspend () -> Unit, ) { val originalWorlds = runSync { snapshotSection("worlds") } try { runSync { ocm.config.set("worlds.world", worldModesets) ocm.saveConfig() Config.reload() } block() } finally { runSync { restoreSection("worlds", originalWorlds) ocm.saveConfig() Config.reload() } } } suspend fun withSwordBlockingDisabled(block: suspend () -> Unit) { val originalAlways = runSync { snapshotSection("always_enabled_modules") } val originalDisabled = runSync { snapshotSection("disabled_modules") } val originalModesets = runSync { snapshotSection("modesets") } try { runSync { val always = ocm .config .getStringList("always_enabled_modules") .filterNot { it.equals("sword-blocking", ignoreCase = true) } ocm.config.set("always_enabled_modules", always) val disabled = ocm .config .getStringList("disabled_modules") .filterNot { it.equals("sword-blocking", ignoreCase = true) } .toMutableList() disabled.add("sword-blocking") ocm.config.set("disabled_modules", disabled) val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("modesets missing") for (key in modesetsSection.getKeys(false)) { val modules = modesetsSection .getStringList(key) .filterNot { it.equals("sword-blocking", ignoreCase = true) } ocm.config.set("modesets.$key", modules) } ocm.saveConfig() Config.reload() } block() } finally { runSync { restoreSection("always_enabled_modules", originalAlways) restoreSection("disabled_modules", originalDisabled) restoreSection("modesets", originalModesets) ocm.saveConfig() Config.reload() } } } suspend fun withSwordBlockingPaperAnimation( enabled: Boolean, block: suspend () -> Unit, ) { val original = runSync { snapshotSection("sword-blocking.paper-animation") } try { runSync { ocm.config.set("sword-blocking.paper-animation", enabled) ocm.saveConfig() Config.reload() } block() } finally { runSync { restoreSection("sword-blocking.paper-animation", original) ocm.saveConfig() Config.reload() } } } lateinit var fake: FakePlayer lateinit var player: Player beforeSpec { runSync { val world = Bukkit.getWorld("world") ?: error("world missing") fake = FakePlayer(testPlugin) fake.spawn(Location(world, 0.0, 100.0, 0.0)) player = Bukkit.getPlayer(fake.uuid) ?: error("player missing") player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.inventory.clear() player.inventory.setItemInOffHand(ItemStack(Material.AIR)) player.updateInventory() } } afterSpec { runSync { fake.removePlayer() } } beforeTest { runSync { setModeset(player, "old") player.inventory.clear() player.inventory.setItemInOffHand(ItemStack(Material.AIR)) player.setItemOnCursor(ItemStack(Material.AIR)) player.inventory.heldItemSlot = 0 player.updateInventory() } } test("hotbar swap keeps food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { player.inventory.setItem(0, ItemStack(Material.BREAD)) player.inventory.setItem(1, ItemStack(Material.STONE)) player.inventory.heldItemSlot = 0 } val before = runSync { player.inventory.getItem(0) } assertNoConsumableRemoval(before, "hotbar food (before)") runSync { Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, 0, 1)) } val after = runSync { player.inventory.getItem(0) } hasConsumableRemoval(after) shouldBe false } test("inventory click keeps slot and cursor food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { runSync { player.inventory.setItem(0, ItemStack(Material.BREAD)) player.setItemOnCursor(ItemStack(Material.CARROT)) } val slotItem = runSync { player.inventory.getItem(0) } val cursorItem = runSync { player.itemOnCursor } assertNoConsumableRemoval(slotItem, "slot food (before)") assertNoConsumableRemoval(cursorItem, "cursor food (before)") val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) click.currentItem = slotItem click.cursor = cursorItem click } runSync { Bukkit.getPluginManager().callEvent(event) } delayTicks(1) val afterSlot = runSync { player.inventory.getItem(0) } val afterCursor = runSync { player.itemOnCursor } hasConsumableRemoval(afterSlot) shouldBe false hasConsumableRemoval(afterCursor) shouldBe false } finally { runSync { player.closeInventory() } } } test("inventory click does not alter swords when no consumable change is needed") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItem(1, ItemStack(Material.STONE)) player.inventory.heldItemSlot = 1 player.setItemOnCursor(ItemStack(Material.IRON_SWORD)) } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val slotItem = runSync { craftMirrorStack(Material.DIAMOND_SWORD) } val cursorItem = runSync { craftMirrorStack(Material.IRON_SWORD) } applyConsumableComponent(slotItem) applyConsumableComponent(cursorItem) assertNoConsumableRemoval(slotItem, "slot sword (before)") assertNoConsumableRemoval(cursorItem, "cursor sword (before)") val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) click.currentItem = slotItem click.cursor = cursorItem click } runSync { Bukkit.getPluginManager().callEvent(event) } delayTicks(1) val afterSlot = runSync { player.inventory.getItem(0) } val afterCursor = runSync { player.itemOnCursor } hasConsumableRemoval(afterSlot) shouldBe false hasConsumableRemoval(afterCursor) shouldBe false } finally { runSync { player.closeInventory() } } } test("stale deferred click reapply does not taint newly selected main-hand sword") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItem(1, ItemStack(Material.IRON_SWORD)) player.inventory.heldItemSlot = 0 player.updateInventory() } runSync { hasConsumableComponent(player.inventory.getItem(0)) shouldBe false hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val click = runSync { InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.NUMBER_KEY, InventoryAction.HOTBAR_SWAP, 0, ) } runSync { Bukkit.getPluginManager().callEvent(click) } // Change selection directly before deferred next-tick reapply runs. runSync { player.inventory.heldItemSlot = 1 player.updateInventory() } delayTicks(1) runSync { player.inventory.heldItemSlot shouldBe 1 player.inventory.itemInMainHand.type shouldBe Material.IRON_SWORD hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } } finally { runSync { player.closeInventory() } } } test("inventory click does not strip consumable component when sword-blocking disabled for player modeset") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "new") } runSync { swordBlocking.isEnabled(player) shouldBe false } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val slotItem = runSync { craftMirrorStack(Material.DIAMOND_SWORD) } val cursorItem = runSync { craftMirrorStack(Material.IRON_SWORD) } applyConsumableComponent(slotItem) applyConsumableComponent(cursorItem) assertNoConsumableRemoval(slotItem, "slot sword (before)") assertNoConsumableRemoval(cursorItem, "cursor sword (before)") val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) click.currentItem = slotItem click.cursor = cursorItem click } runSync { Bukkit.getPluginManager().callEvent(event) } // Assert the same objects we supplied to the event were not mutated. hasConsumableComponent(slotItem) shouldBe true hasConsumableComponent(cursorItem) shouldBe true } finally { runSync { player.closeInventory() } } } test("inventory click does not strip consumable component when sword-blocking disabled in world defaults") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } withWorldModesets(listOf("new")) { runSync { setModeset(player, null) } runSync { swordBlocking.isEnabled(player) shouldBe false } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val slotItem = runSync { craftMirrorStack(Material.DIAMOND_SWORD) } val cursorItem = runSync { craftMirrorStack(Material.IRON_SWORD) } applyConsumableComponent(slotItem) applyConsumableComponent(cursorItem) assertNoConsumableRemoval(slotItem, "slot sword (before)") assertNoConsumableRemoval(cursorItem, "cursor sword (before)") val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) click.currentItem = slotItem click.cursor = cursorItem click } runSync { Bukkit.getPluginManager().callEvent(event) } // Assert the same objects we supplied to the event were not mutated. hasConsumableComponent(slotItem) shouldBe true hasConsumableComponent(cursorItem) shouldBe true } finally { runSync { player.closeInventory() } } } } test("modeset change to disabled strips sword consumable component from hand") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(craftMirrorStack(Material.DIAMOND_SWORD)) } // Seed the component on the actual hand item. runSync { val main = player.inventory.itemInMainHand applyConsumableComponent(main) player.inventory.setItemInMainHand(main) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } // Change modeset so sword-blocking is disabled for this player. runSync { setModeset(player, "new") swordBlocking.isEnabled(player) shouldBe false // Simulate the plugin's modeset-change hook. ModuleLoader.getModules().forEach { it.onModesetChange(player) } } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } test("disabled_modules clears sword consumable component after reload") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(craftMirrorStack(Material.DIAMOND_SWORD)) } runSync { val main = player.inventory.itemInMainHand applyConsumableComponent(main) player.inventory.setItemInMainHand(main) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } withSwordBlockingDisabled { runSync { swordBlocking.isEnabled(player) shouldBe false } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("disabled_modules prevents sword consumable component on right-click") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) } withSwordBlockingDisabled { runSync { swordBlocking.isEnabled(player) shouldBe false } rightClickMainHand(player) delayTicks(1) runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("reload toggle disables and re-enables sword consumable component") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) } rightClickMainHand(player) delayTicks(1) runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } withSwordBlockingDisabled { runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } delayTicks(1) rightClickMainHand(player) delayTicks(1) runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } } test("paper-animation config false clears stale sword consumable component after reload") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(craftMirrorStack(Material.DIAMOND_SWORD)) } runSync { val main = player.inventory.itemInMainHand applyConsumableComponent(main) player.inventory.setItemInMainHand(main) hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } withSwordBlockingPaperAnimation(false) { runSync { swordBlocking.isEnabled(player) shouldBe true hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("paper-animation config false prevents swap lifecycle from re-applying sword consumable component") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } withSwordBlockingPaperAnimation(false) { val event = runSync { PlayerSwapHandItemsEvent( player, player.inventory.itemInMainHand.clone(), player.inventory.itemInOffHand.clone(), ) } runSync { Bukkit.getPluginManager().callEvent(event) } delayTicks(1) runSync { swordBlocking.isEnabled(player) shouldBe true hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("disabled_modules clears stored sword consumable components after reload") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.STONE)) } runSync { val stored = craftMirrorStack(Material.IRON_SWORD) applyConsumableComponent(stored) player.inventory.setItem(2, stored) } runSync { hasConsumableComponent(player.inventory.getItem(2)) shouldBe true } withSwordBlockingDisabled { runSync { hasConsumableComponent(player.inventory.getItem(2)) shouldBe false } } } test("disabled_modules keeps offhand unchanged on right-click") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) } val offhandBefore = runSync { player.inventory.itemInOffHand } assertNoConsumableRemoval(offhandBefore, "offhand item (before disabled right-click)") withSwordBlockingDisabled { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.APPLE hasConsumableRemoval(player.inventory.itemInOffHand) shouldBe false } } } test("old client uses offhand shield instead of consumable animation") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("unknown client version uses offhand shield fallback instead of consumable animation") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val unknownVersion = runCatching { unknownPacketEventsClientVersionName() }.getOrNull() ?: run { println("Skipping: PacketEvents unknown client version enum constant unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } withPacketEventsClientVersion(player, unknownVersion) { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("missing PacketEvents client-version resolver fails safe to offhand shield fallback") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } val moduleClass = ModuleSwordBlocking::class.java val packetEventsGetClientVersionField = moduleClass.getDeclaredField("packetEventsGetClientVersion") val minClientVersionField = moduleClass.getDeclaredField("minClientVersion") packetEventsGetClientVersionField.isAccessible = true minClientVersionField.isAccessible = true val originalGetClientVersion = runSync { packetEventsGetClientVersionField.get(swordBlocking) } val originalMinClientVersion = runSync { minClientVersionField.get(swordBlocking) } try { runSync { packetEventsGetClientVersionField.set(swordBlocking, null) if (minClientVersionField.get(swordBlocking) == null) { minClientVersionField.set(swordBlocking, packetEventsClientVersion("V_1_20_5")) } } rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } finally { runSync { packetEventsGetClientVersionField.set(swordBlocking, originalGetClientVersion) minClientVersionField.set(swordBlocking, originalMinClientVersion) } } } test("middle-click in custom GUI does not mutate held sword components") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } val gui = runSync { Bukkit.createInventory(null, 9, "OCM Test GUI") } runSync { gui.setItem(0, ItemStack(Material.STONE)) } val view = runSync { player.openInventory(gui) } ?: error("inventory view missing") try { val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.MIDDLE, InventoryAction.CLONE_STACK, ) click.currentItem = gui.getItem(0) click } runSync { Bukkit.getPluginManager().callEvent(event) } delayTicks(1) runSync { event.isCancelled shouldBe false hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } finally { runSync { player.closeInventory() } } } test("inventory drag in custom GUI does not rewrite top-inventory swords") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.STONE)) } val gui = runSync { Bukkit.createInventory(null, 9, "OCM Drag GUI") } val topSword = runSync { craftMirrorStack(Material.DIAMOND_SWORD) } applyConsumableComponent(topSword) runSync { hasConsumableComponent(topSword) shouldBe true gui.setItem(0, topSword) } val view = runSync { player.openInventory(gui) } ?: error("inventory view missing") try { val drag = runSync { InventoryDragEvent( view, ItemStack(Material.CARROT), ItemStack(Material.CARROT), false, mapOf(0 to ItemStack(Material.CARROT)), ) } runSync { Bukkit.getPluginManager().callEvent(drag) } delayTicks(1) val afterTop = runSync { gui.getItem(0) } runSync { drag.isCancelled shouldBe false hasConsumableComponent(afterTop) shouldBe true } } finally { runSync { player.closeInventory() } } } test("stale deferred drag reapply does not taint newly selected main-hand sword") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItem(1, ItemStack(Material.IRON_SWORD)) player.inventory.heldItemSlot = 0 player.updateInventory() } runSync { hasConsumableComponent(player.inventory.getItem(0)) shouldBe false hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } val gui = runSync { Bukkit.createInventory(null, 9, "OCM Drag Stale Slot") } val view = runSync { player.openInventory(gui) } ?: error("inventory view missing") try { val drag = runSync { InventoryDragEvent( view, ItemStack(Material.CARROT), ItemStack(Material.CARROT), false, mapOf(9 to ItemStack(Material.CARROT)), ) } runSync { Bukkit.getPluginManager().callEvent(drag) } // Move to a different held slot before deferred next-tick reapply runs. runSync { player.inventory.heldItemSlot = 1 player.updateInventory() } delayTicks(1) runSync { player.inventory.heldItemSlot shouldBe 1 player.inventory.itemInMainHand.type shouldBe Material.IRON_SWORD hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } } finally { runSync { player.closeInventory() } } } test("stale deferred drag context does not mutate dragged bottom slot") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItem(1, ItemStack(Material.IRON_SWORD)) player.inventory.heldItemSlot = 0 player.updateInventory() } val gui = runSync { Bukkit.createInventory(null, 9, "OCM Drag Cleanup Stale") } val view = runSync { player.openInventory(gui) } ?: error("inventory view missing") try { val draggedSword = runSync { craftMirrorStack(Material.DIAMOND_SWORD) } applyConsumableComponent(draggedSword) runSync { hasConsumableComponent(draggedSword) shouldBe true view.setItem(9, draggedSword) } val drag = runSync { InventoryDragEvent( view, ItemStack(Material.CARROT), ItemStack(Material.CARROT), false, mapOf(9 to ItemStack(Material.CARROT)), ) } runSync { Bukkit.getPluginManager().callEvent(drag) } // Move to a different held slot before deferred next-tick reapply runs. runSync { player.inventory.heldItemSlot = 1 player.updateInventory() } delayTicks(1) val slotAfter = runSync { view.getItem(9) } runSync { player.inventory.heldItemSlot shouldBe 1 hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false hasConsumableComponent(slotAfter) shouldBe true } } finally { runSync { player.closeInventory() } } } test("stale deferred drag reapply no-ops after inventory view change") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.heldItemSlot = 0 player.updateInventory() } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } val firstGui = runSync { Bukkit.createInventory(null, 9, "OCM Drag First View") } val firstView = runSync { player.openInventory(firstGui) } ?: error("first inventory view missing") try { val drag = runSync { InventoryDragEvent( firstView, ItemStack(Material.CARROT), ItemStack(Material.CARROT), false, mapOf(9 to ItemStack(Material.CARROT)), ) } runSync { Bukkit.getPluginManager().callEvent(drag) } val secondGui = runSync { Bukkit.createInventory(null, 9, "OCM Drag Second View") } runSync { player.openInventory(secondGui) } delayTicks(1) runSync { player.openInventory.topInventory shouldBe secondGui hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } finally { runSync { player.closeInventory() } } } test("old client shield fallback restores offhand item on hotbar change") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItem(0, ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItem(1, ItemStack(Material.STONE)) player.inventory.heldItemSlot = 0 player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) } withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD } runSync { player.inventory.heldItemSlot = 1 Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, 0, 1)) } delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.APPLE } } } test("legacy fallback does not cancel custom GUI shield-icon clicks") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD } val gui = runSync { Bukkit.createInventory(null, 9, "Shield GUI") } runSync { gui.setItem(0, ItemStack(Material.SHIELD)) } val view = runSync { player.openInventory(gui) } ?: error("inventory view missing") try { val click = runSync { val event = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) event.currentItem = gui.getItem(0) event } runSync { Bukkit.getPluginManager().callEvent(click) } delayTicks(1) runSync { click.isCancelled shouldBe false } } finally { runSync { player.closeInventory() } } } } test("legacy fallback does not cancel dropping unrelated shield items") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD } val dropped = runSync { player.world.dropItem( player.location, ItemStack(Material.SHIELD).apply { itemMeta = itemMeta?.apply { setDisplayName("Unrelated Shield") } }, ) } try { val dropEvent = runSync { PlayerDropItemEvent(player, dropped) } runSync { Bukkit.getPluginManager().callEvent(dropEvent) } runSync { dropEvent.isCancelled shouldBe false } } finally { runSync { dropped.remove() } } } } test("legacy fallback still blocks swapping temporary offhand shield") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) } withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD } val swapEvent = runSync { PlayerSwapHandItemsEvent( player, player.inventory.itemInMainHand, player.inventory.itemInOffHand, ) } runSync { Bukkit.getPluginManager().callEvent(swapEvent) } runSync { swapEvent.isCancelled shouldBe true } } } test("legacy death replaces only temporary shield drop and clears legacy state once") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) player.updateInventory() } val storedItemsField = ModuleSwordBlocking::class.java.getDeclaredField("storedItems") val legacyStatesField = ModuleSwordBlocking::class.java.getDeclaredField("legacyStates") storedItemsField.isAccessible = true legacyStatesField.isAccessible = true withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) @Suppress("UNCHECKED_CAST") val storedItems = runSync { storedItemsField.get(swordBlocking) as MutableMap } runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD storedItems.containsKey(player.uniqueId) shouldBe true val legacyStates = legacyStatesField.get(swordBlocking) as Map<*, *> legacyStates.containsKey(player.uniqueId) shouldBe true } val drops = mutableListOf( ItemStack(Material.SHIELD), ItemStack(Material.SHIELD), ) val deathEvent = runSync { syntheticPlayerDeathEvent(player, drops) } runSync { Bukkit.getPluginManager().callEvent(deathEvent) } @Suppress("UNCHECKED_CAST") val dropsAfter = runSync { (deathEvent.drops as MutableList).toList() } runSync { dropsAfter.any { it == null } shouldBe false dropsAfter.count { it?.type == Material.APPLE } shouldBe 1 dropsAfter.count { it?.type == Material.SHIELD } shouldBe 1 storedItems.containsKey(player.uniqueId) shouldBe false val legacyStates = legacyStatesField.get(swordBlocking) as Map<*, *> legacyStates.containsKey(player.uniqueId) shouldBe false } } } test("legacy death with keepInventory does not rewrite drops and still clears state") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) player.updateInventory() } val storedItemsField = ModuleSwordBlocking::class.java.getDeclaredField("storedItems") val legacyStatesField = ModuleSwordBlocking::class.java.getDeclaredField("legacyStates") storedItemsField.isAccessible = true legacyStatesField.isAccessible = true withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) @Suppress("UNCHECKED_CAST") val storedItems = runSync { storedItemsField.get(swordBlocking) as MutableMap } runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD storedItems.containsKey(player.uniqueId) shouldBe true } val drops = mutableListOf(ItemStack(Material.SHIELD), ItemStack(Material.STONE)) val deathEvent = runSync { syntheticPlayerDeathEvent(player, drops) } runSync { deathEvent.keepInventory = true } runSync { Bukkit.getPluginManager().callEvent(deathEvent) } @Suppress("UNCHECKED_CAST") val dropsAfter = runSync { (deathEvent.drops as MutableList).toList() } runSync { dropsAfter.map { it?.type } shouldBe listOf(Material.SHIELD, Material.STONE) player.inventory.itemInOffHand.type shouldBe Material.APPLE storedItems.containsKey(player.uniqueId) shouldBe false val legacyStates = legacyStatesField.get(swordBlocking) as Map<*, *> legacyStates.containsKey(player.uniqueId) shouldBe false } } } test("paper-animation swap restores stale stored offhand item before clearing legacy state") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.SHIELD)) player.updateInventory() } val storedItemsField = ModuleSwordBlocking::class.java.getDeclaredField("storedItems") val legacyStatesField = ModuleSwordBlocking::class.java.getDeclaredField("legacyStates") storedItemsField.isAccessible = true legacyStatesField.isAccessible = true @Suppress("UNCHECKED_CAST") val storedItems = storedItemsField.get(swordBlocking) as MutableMap withPacketEventsClientVersion(player, "V_1_21_11") { runSync { storedItems[player.uniqueId] = ItemStack(Material.APPLE) } val swapEvent = runSync { PlayerSwapHandItemsEvent( player, player.inventory.itemInMainHand, player.inventory.itemInOffHand, ) } runSync { Bukkit.getPluginManager().callEvent(swapEvent) } runSync { swapEvent.isCancelled shouldBe false player.inventory.itemInOffHand.type shouldBe Material.APPLE storedItems.containsKey(player.uniqueId) shouldBe false val legacyStates = legacyStatesField.get(swordBlocking) as Map<*, *> legacyStates.containsKey(player.uniqueId) shouldBe false } } } test("modeset change after disabled reload does not reapply sword consumable component") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(craftMirrorStack(Material.DIAMOND_SWORD)) } runSync { val main = player.inventory.itemInMainHand applyConsumableComponent(main) player.inventory.setItemInMainHand(main) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true } withSwordBlockingDisabled { runSync { setModeset(player, "new") ModuleLoader.getModules().forEach { it.onModesetChange(player) } } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } runSync { setModeset(player, "old") ModuleLoader.getModules().forEach { it.onModesetChange(player) } } runSync { swordBlocking.isEnabled(player) shouldBe false hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false } } } test("number-key hotbar swap keeps food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { runSync { player.inventory.setItem(0, ItemStack(Material.STONE)) player.inventory.setItem(2, ItemStack(Material.BREAD)) } val hotbarItem = runSync { player.inventory.getItem(2) } assertNoConsumableRemoval(hotbarItem, "hotbar button food (before)") val event = runSync { val click = InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.NUMBER_KEY, InventoryAction.HOTBAR_SWAP, 2, ) click.currentItem = player.inventory.getItem(0) click } runSync { Bukkit.getPluginManager().callEvent(event) } delayTicks(1) val after = runSync { player.inventory.getItem(2) } hasConsumableRemoval(after) shouldBe false } finally { runSync { player.closeInventory() } } } test("stale deferred swap reapply does not taint newly selected main-hand sword") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val slot0Sword = craftMirrorStack(Material.DIAMOND_SWORD) applyConsumableComponent(slot0Sword) hasConsumableComponent(slot0Sword) shouldBe true player.inventory.setItem(0, slot0Sword) player.inventory.setItem(1, ItemStack(Material.IRON_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.STICK)) player.inventory.heldItemSlot = 0 player.updateInventory() } runSync { hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } val event = runSync { PlayerSwapHandItemsEvent(player, player.inventory.itemInMainHand, player.inventory.itemInOffHand) } runSync { Bukkit.getPluginManager().callEvent(event) } runSync { val main = player.inventory.itemInMainHand val off = player.inventory.itemInOffHand player.inventory.setItemInMainHand(off) player.inventory.setItemInOffHand(main) } // Change held slot directly before deferred next-tick swap handling runs. runSync { player.inventory.heldItemSlot = 1 player.updateInventory() } delayTicks(1) runSync { player.inventory.heldItemSlot shouldBe 1 player.inventory.itemInMainHand.type shouldBe Material.IRON_SWORD hasConsumableComponent(player.inventory.getItem(1)) shouldBe false player.inventory.itemInOffHand.type shouldBe Material.DIAMOND_SWORD hasConsumableComponent(player.inventory.itemInOffHand) shouldBe false } } test("stale deferred swap reapply no-ops when inventory view changes, while offhand cleanup still runs") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val mainSword = craftMirrorStack(Material.DIAMOND_SWORD) applyConsumableComponent(mainSword) hasConsumableComponent(mainSword) shouldBe true player.inventory.setItem(0, mainSword) val offhandSword = craftMirrorStack(Material.IRON_SWORD) applyConsumableComponent(offhandSword) hasConsumableComponent(offhandSword) shouldBe true player.inventory.setItemInOffHand(offhandSword) player.inventory.heldItemSlot = 0 player.updateInventory() } val firstGui = runSync { Bukkit.createInventory(null, 9, "OCM Swap First View") } runSync { player.openInventory(firstGui) } val swapEvent = runSync { PlayerSwapHandItemsEvent(player, player.inventory.itemInMainHand, player.inventory.itemInOffHand) } runSync { Bukkit.getPluginManager().callEvent(swapEvent) } runSync { val main = player.inventory.itemInMainHand val off = player.inventory.itemInOffHand player.inventory.setItemInMainHand(off) player.inventory.setItemInOffHand(main) } // Keep the same held slot but change the open view before deferred task runs. val secondGui = runSync { Bukkit.createInventory(null, 9, "OCM Swap Second View") } runSync { player.inventory.setItem(0, ItemStack(Material.GOLDEN_SWORD)) player.openInventory(secondGui) player.updateInventory() } delayTicks(1) runSync { player.openInventory.topInventory shouldBe secondGui player.inventory.heldItemSlot shouldBe 0 player.inventory.itemInMainHand.type shouldBe Material.GOLDEN_SWORD hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false player.inventory.itemInOffHand.type shouldBe Material.DIAMOND_SWORD hasConsumableComponent(player.inventory.itemInOffHand) shouldBe false } runSync { player.closeInventory() } } test("swap hand keeps food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { player.inventory.setItemInMainHand(ItemStack(Material.STONE)) player.inventory.setItemInOffHand(ItemStack(Material.BREAD)) } val offhandBefore = runSync { player.inventory.itemInOffHand } assertNoConsumableRemoval(offhandBefore, "offhand food (before)") val event = runSync { PlayerSwapHandItemsEvent(player, player.inventory.itemInMainHand, player.inventory.itemInOffHand) } runSync { Bukkit.getPluginManager().callEvent(event) } runSync { val main = player.inventory.itemInMainHand val off = player.inventory.itemInOffHand player.inventory.setItemInMainHand(off) player.inventory.setItemInOffHand(main) } delayTicks(1) val mainAfter = runSync { player.inventory.itemInMainHand } val offAfter = runSync { player.inventory.itemInOffHand } val foodAfter = if (mainAfter.type == Material.BREAD) mainAfter else offAfter hasConsumableRemoval(foodAfter) shouldBe false } test("dropping food keeps consumable component") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val drop = runSync { player.world.dropItem(player.location, ItemStack(Material.BREAD)) } try { val before = runSync { drop.itemStack } assertNoConsumableRemoval(before, "dropped food (before)") runSync { Bukkit.getPluginManager().callEvent(PlayerDropItemEvent(player, drop)) } val after = runSync { drop.itemStack } hasConsumableRemoval(after) shouldBe false } finally { runSync { drop.remove() } } } test("world change keeps hand food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { player.inventory.setItemInMainHand(ItemStack(Material.BREAD)) player.inventory.setItemInOffHand(ItemStack(Material.CARROT)) } val beforeMain = runSync { player.inventory.itemInMainHand } val beforeOff = runSync { player.inventory.itemInOffHand } assertNoConsumableRemoval(beforeMain, "main hand food (before world change)") assertNoConsumableRemoval(beforeOff, "offhand food (before world change)") runSync { Bukkit.getPluginManager().callEvent(PlayerChangedWorldEvent(player, player.world)) } val afterMain = runSync { player.inventory.itemInMainHand } val afterOff = runSync { player.inventory.itemInOffHand } hasConsumableRemoval(afterMain) shouldBe false hasConsumableRemoval(afterOff) shouldBe false } test("quit event keeps hand food consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { player.inventory.setItemInMainHand(ItemStack(Material.BREAD)) player.inventory.setItemInOffHand(ItemStack(Material.CARROT)) } val beforeMain = runSync { player.inventory.itemInMainHand } val beforeOff = runSync { player.inventory.itemInOffHand } assertNoConsumableRemoval(beforeMain, "main hand food (before quit)") assertNoConsumableRemoval(beforeOff, "offhand food (before quit)") runSync { Bukkit.getPluginManager().callEvent(PlayerQuitEvent(player, "test")) } val afterMain = runSync { player.inventory.itemInMainHand } val afterOff = runSync { player.inventory.itemInOffHand } hasConsumableRemoval(afterMain) shouldBe false hasConsumableRemoval(afterOff) shouldBe false } test("world change strips consumable component from hand and stored swords") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val main = craftMirrorStack(Material.DIAMOND_SWORD) val off = craftMirrorStack(Material.IRON_SWORD) val stored = craftMirrorStack(Material.GOLDEN_SWORD) applyConsumableComponent(main) applyConsumableComponent(off) applyConsumableComponent(stored) player.inventory.setItemInMainHand(main) player.inventory.setItemInOffHand(off) player.inventory.setItem(2, stored) player.updateInventory() } withPacketEventsClientVersion(player, "V_1_21_11") { runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true hasConsumableComponent(player.inventory.itemInOffHand) shouldBe true hasConsumableComponent(player.inventory.getItem(2)) shouldBe true } runSync { Bukkit.getPluginManager().callEvent(PlayerChangedWorldEvent(player, player.world)) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false hasConsumableComponent(player.inventory.itemInOffHand) shouldBe false hasConsumableComponent(player.inventory.getItem(2)) shouldBe false } } } test("dropping sword strips consumable component from dropped stack") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val drop = runSync { val droppedSword = craftMirrorStack(Material.DIAMOND_SWORD) applyConsumableComponent(droppedSword) player.world.dropItem(player.location, droppedSword) } try { withPacketEventsClientVersion(player, "V_1_21_11") { runSync { hasConsumableComponent(drop.itemStack) shouldBe true } runSync { Bukkit.getPluginManager().callEvent(PlayerDropItemEvent(player, drop)) } runSync { hasConsumableComponent(drop.itemStack) shouldBe false } } } finally { runSync { drop.remove() } } } test("death event strips consumable component from sword drops") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } val drops = mutableListOf(runSync { craftMirrorStack(Material.DIAMOND_SWORD) }) runSync { applyConsumableComponent(drops[0]) hasConsumableComponent(drops[0]) shouldBe true } withPacketEventsClientVersion(player, "V_1_21_11") { val deathEvent = runSync { syntheticPlayerDeathEvent(player, drops) } runSync { Bukkit.getPluginManager().callEvent(deathEvent) } runSync { hasConsumableComponent(drops[0]) shouldBe false } } } test("held-slot transition strips previous sword and applies new sword consumable") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val previous = craftMirrorStack(Material.DIAMOND_SWORD) val next = craftMirrorStack(Material.IRON_SWORD) applyConsumableComponent(previous) player.inventory.setItem(0, previous) player.inventory.setItem(1, next) player.inventory.heldItemSlot = 0 player.updateInventory() } withPacketEventsClientVersion(player, "V_1_21_11") { runSync { hasConsumableComponent(player.inventory.getItem(0)) shouldBe true hasConsumableComponent(player.inventory.getItem(1)) shouldBe false } runSync { Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, 0, 1)) } runSync { hasConsumableComponent(player.inventory.getItem(0)) shouldBe false hasConsumableComponent(player.inventory.getItem(1)) shouldBe true } } } test("quit event strips consumable component from hand and stored swords") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val main = craftMirrorStack(Material.DIAMOND_SWORD) val off = craftMirrorStack(Material.IRON_SWORD) val stored = craftMirrorStack(Material.GOLDEN_SWORD) applyConsumableComponent(main) applyConsumableComponent(off) applyConsumableComponent(stored) player.inventory.setItemInMainHand(main) player.inventory.setItemInOffHand(off) player.inventory.setItem(2, stored) player.updateInventory() } withPacketEventsClientVersion(player, "V_1_21_11") { runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true hasConsumableComponent(player.inventory.itemInOffHand) shouldBe true hasConsumableComponent(player.inventory.getItem(2)) shouldBe true } runSync { Bukkit.getPluginManager().callEvent(PlayerQuitEvent(player, "test")) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false hasConsumableComponent(player.inventory.itemInOffHand) shouldBe false hasConsumableComponent(player.inventory.getItem(2)) shouldBe false } } } test("join event strips consumable component from hand and stored swords") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL val main = craftMirrorStack(Material.DIAMOND_SWORD) val off = craftMirrorStack(Material.IRON_SWORD) val stored = craftMirrorStack(Material.GOLDEN_SWORD) applyConsumableComponent(main) applyConsumableComponent(off) applyConsumableComponent(stored) player.inventory.setItemInMainHand(main) player.inventory.setItemInOffHand(off) player.inventory.setItem(2, stored) player.updateInventory() } withPacketEventsClientVersion(player, "V_1_21_11") { runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe true hasConsumableComponent(player.inventory.itemInOffHand) shouldBe true hasConsumableComponent(player.inventory.getItem(2)) shouldBe true } runSync { Bukkit.getPluginManager().callEvent(PlayerJoinEvent(player, "test")) } runSync { hasConsumableComponent(player.inventory.itemInMainHand) shouldBe false hasConsumableComponent(player.inventory.itemInOffHand) shouldBe false hasConsumableComponent(player.inventory.getItem(2)) shouldBe false } } } test("modeset disable clears stale legacy fallback shield state") { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") return@test } runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.APPLE)) player.updateInventory() } val storedItemsField = ModuleSwordBlocking::class.java.getDeclaredField("storedItems") val legacyStatesField = ModuleSwordBlocking::class.java.getDeclaredField("legacyStates") storedItemsField.isAccessible = true legacyStatesField.isAccessible = true withPacketEventsClientVersion(player, "V_1_20_3") { rightClickMainHand(player) delayTicks(1) @Suppress("UNCHECKED_CAST") val storedItems = runSync { storedItemsField.get(swordBlocking) as MutableMap } runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD storedItems.containsKey(player.uniqueId) shouldBe true } runSync { setModeset(player, "new") swordBlocking.isEnabled(player) shouldBe false ModuleLoader.getModules().forEach { it.onModesetChange(player) } } runSync { player.inventory.itemInOffHand.type shouldBe Material.APPLE storedItems.containsKey(player.uniqueId) shouldBe false val legacyStates = legacyStatesField.get(swordBlocking) as Map<*, *> legacyStates.containsKey(player.uniqueId) shouldBe false } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/CopperToolsIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XMaterial import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.StringSpec import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages import org.bukkit.Material import org.bukkit.plugin.java.JavaPlugin @OptIn(ExperimentalKotest::class) class CopperToolsIntegrationTest : StringSpec({ val plugin = JavaPlugin.getPlugin(OCMTestMain::class.java) extension(MainThreadDispatcherExtension(plugin)) val copperMaterials = listOf( XMaterial.COPPER_SWORD, XMaterial.COPPER_AXE, XMaterial.COPPER_PICKAXE, XMaterial.COPPER_SHOVEL, XMaterial.COPPER_HOE ).mapNotNull { xmat -> val material = runCatching { Material.valueOf(xmat.name) }.getOrNull() material?.let { xmat to it } } if (copperMaterials.isEmpty()) { "copper tools not present on this version" { plugin.logger.info("Copper tools not present on this version; skipping copper damage checks.") } } else { copperMaterials.forEach { (xmat, material) -> "copper tool damage is configurable for ${xmat.name}" { val damage = WeaponDamages.getDamage(material) if (damage < 0.0) { throw AssertionError("Expected ${xmat.name} to be present in old-tool-damage.damages (config.yml)") } } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/CustomWeaponDamageIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.doubles.shouldBeExactly import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleOldToolDamage import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.entity.Trident import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable import java.util.concurrent.atomic.AtomicReference @OptIn(ExperimentalKotest::class) class CustomWeaponDamageIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val toolDamageModule = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleOldToolDamage not registered") extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } suspend fun TestScope.withWeaponConfig( tridentMelee: Double?, tridentThrown: Double?, mace: Double?, block: suspend TestScope.() -> Unit ) { val snapshot = ocm.config.getConfigurationSection("old-tool-damage.damages")?.getValues(false) ?: emptyMap() fun set(path: String, value: Double?) { if (value == null) return ocm.config.set("old-tool-damage.damages.$path", value) } try { set("TRIDENT", tridentMelee) set("TRIDENT_THROWN", tridentThrown) set("MACE", mace) toolDamageModule.reload() WeaponDamages.initialise(ocm) ModuleLoader.toggleModules() block() } finally { // restore snapshot.forEach { (k, v) -> ocm.config.set("old-tool-damage.damages.$k", v) } toolDamageModule.reload() WeaponDamages.initialise(ocm) ModuleLoader.toggleModules() } } data class SpawnedPlayer(val fake: FakePlayer, val player: Player) fun spawnFake(location: Location): SpawnedPlayer { lateinit var fake: FakePlayer lateinit var player: Player runSync { fake = FakePlayer(testPlugin) fake.spawn(location) player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val data = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) data.setModesetForWorld(player.world.uid, "old") kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, data) } return SpawnedPlayer(fake, player) } fun cleanup(vararg players: SpawnedPlayer) { runSync { players.forEach { p -> p.fake.removePlayer() } } } test("trident melee uses configured base damage") { val tridentMat = Material.matchMaterial("TRIDENT") ?: return@test withWeaponConfig(tridentMelee = 12.0, tridentThrown = null, mace = null) { val world = checkNotNull(Bukkit.getWorld("world")) val attacker = spawnFake(Location(world, 0.0, 100.0, 0.0)) val victim = spawnFake(Location(world, 1.5, 100.0, 0.0)) val damageCapture = AtomicReference() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onHit(event: EntityDamageByEntityEvent) { if (event.damager == attacker.player && event.entity == victim.player) { damageCapture.set(event.damage) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) attacker.player.inventory.setItemInMainHand(ItemStack(tridentMat)) Bukkit.getPluginManager().callEvent( EntityDamageByEntityEvent(attacker.player, victim.player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 8.0) ) HandlerList.unregisterAll(listener) } val dealt = damageCapture.get() ?: error("No damage recorded") dealt shouldBe (12.0 plusOrMinus 0.05) cleanup(attacker, victim) } } test("thrown trident uses configured damage") { val tridentMat = Material.matchMaterial("TRIDENT") ?: return@test if (!Reflector.versionIsNewerOrEqualTo(1, 13, 0)) return@test withWeaponConfig(tridentMelee = null, tridentThrown = 15.0, mace = null) { val world = checkNotNull(Bukkit.getWorld("world")) val victim = spawnFake(Location(world, 0.0, 100.0, 0.0)) val tridentRef = AtomicReference() runSync { tridentRef.set( world.spawn(world.spawnLocation, Trident::class.java).apply { this.item = ItemStack(tridentMat) } ) } val damageCapture = AtomicReference() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onHit(event: EntityDamageByEntityEvent) { if (event.damager == tridentRef.get() && event.entity == victim.player) { damageCapture.set(event.damage) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) Bukkit.getPluginManager().callEvent( EntityDamageByEntityEvent(tridentRef.get(), victim.player, EntityDamageEvent.DamageCause.PROJECTILE, 8.0) ) HandlerList.unregisterAll(listener) } val dealt = damageCapture.get() ?: error("No damage recorded") dealt shouldBeExactly 15.0 cleanup(victim) runSync { tridentRef.get()?.remove() } } } test("mace melee uses configured base damage") { val maceMat = Material.matchMaterial("MACE") ?: return@test withWeaponConfig(tridentMelee = null, tridentThrown = null, mace = 10.0) { val world = checkNotNull(Bukkit.getWorld("world")) val attacker = spawnFake(Location(world, 0.0, 100.0, 0.0)) val victim = spawnFake(Location(world, 1.5, 100.0, 0.0)) val damageCapture = AtomicReference() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onHit(event: EntityDamageByEntityEvent) { if (event.damager == attacker.player && event.entity == victim.player) { damageCapture.set(event.damage) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) attacker.player.inventory.setItemInMainHand(ItemStack(maceMat)) Bukkit.getPluginManager().callEvent( EntityDamageByEntityEvent(attacker.player, victim.player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 6.0) ) HandlerList.unregisterAll(listener) } val dealt = damageCapture.get() ?: error("No damage recorded") dealt shouldBe (10.0 plusOrMinus 0.05) cleanup(attacker, victim) } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/DisableOffhandIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleDisableOffHand import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class DisableOffhandIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleDisableOffHand not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun setModeset(player: Player, modeset: String) { val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) setPlayerData(player.uniqueId, playerData) } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = checkNotNull(Bukkit.getServer().getWorld("world")) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(Location(world, 0.0, 100.0, 0.0)) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { player.inventory.clear() player.inventory.setItemInOffHand(ItemStack(Material.SHIELD)) setModeset(player, "new") } } test("modeset-change handler ignores players without disable-offhand enabled") { runSync { module.isEnabled(player) shouldBe false val offhand = player.inventory.itemInOffHand.clone() module.onModesetChange(player) player.inventory.itemInOffHand.type shouldBe offhand.type player.inventory.itemInOffHand.amount shouldBe offhand.amount } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/DisableOffhandReflectionIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.entity.Player import org.bukkit.event.inventory.ClickType import org.bukkit.event.inventory.InventoryAction import org.bukkit.event.inventory.InventoryClickEvent import org.bukkit.event.inventory.InventoryType import org.bukkit.inventory.Inventory import org.bukkit.inventory.InventoryView import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class DisableOffhandReflectionIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } lateinit var fake: FakePlayer lateinit var player: Player beforeSpec { runSync { val world = Bukkit.getWorld("world") ?: error("world missing") fake = FakePlayer(testPlugin) fake.spawn(Location(world, 0.0, 100.0, 0.0)) player = Bukkit.getPlayer(fake.uuid) ?: error("player missing") player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false } } afterSpec { runSync { fake.removePlayer() } } beforeTest { runSync { player.closeInventory() } } test("reflective InventoryClickEvent getView works") { val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val event = runSync { InventoryClickEvent( view, InventoryType.SlotType.CONTAINER, 0, ClickType.LEFT, InventoryAction.PICKUP_ALL, ) } val method = Reflector.getMethod(event.javaClass, "getView") ?: error("getView missing") val reflectedView = Reflector.invokeMethod(method, event) reflectedView shouldBe view } finally { runSync { player.closeInventory() } } } test("reflective InventoryView access returns top and bottom inventories") { val view = runSync { player.openInventory(player.inventory) } ?: error("inventory view missing") try { val bottomMethod = Reflector.getMethod(view.javaClass, "getBottomInventory") ?: error("getBottomInventory missing") val topMethod = Reflector.getMethod(view.javaClass, "getTopInventory") ?: error("getTopInventory missing") val bottom = Reflector.invokeMethod(bottomMethod, view) ?: error("bottom inventory missing") val top = Reflector.invokeMethod(topMethod, view) ?: error("top inventory missing") bottom.type shouldBe InventoryType.PLAYER } finally { runSync { player.closeInventory() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/EnderpearlCooldownIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.longs.shouldBeGreaterThan import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleDisableEnderpearlCooldown import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.EnderPearl import org.bukkit.entity.Player import org.bukkit.event.entity.ProjectileLaunchEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class EnderpearlCooldownIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModuleDisableEnderpearlCooldown not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } fun setModeset(player: Player, modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) ModuleLoader.toggleModules() } suspend fun withConfig(cooldownSeconds: Int, showMessage: Boolean, block: suspend () -> Unit) { val oldCooldown = ocm.config.getInt("disable-enderpearl-cooldown.cooldown") val oldShow = ocm.config.getBoolean("disable-enderpearl-cooldown.showMessage") try { runSync { ocm.config.set("disable-enderpearl-cooldown.cooldown", cooldownSeconds) ocm.config.set("disable-enderpearl-cooldown.showMessage", showMessage) module.reload() ModuleLoader.toggleModules() } block() } finally { runSync { ocm.config.set("disable-enderpearl-cooldown.cooldown", oldCooldown) ocm.config.set("disable-enderpearl-cooldown.showMessage", oldShow) module.reload() ModuleLoader.toggleModules() } } } fun firePearlLaunchEvent(player: Player): ProjectileLaunchEvent { // Spawn a pearl entity directly; the module cancels this and launches a replacement. val pearl = runSync { val world = player.world val entity = world.spawn(player.eyeLocation, EnderPearl::class.java) entity.shooter = player entity } val event = ProjectileLaunchEvent(pearl) runSync { Bukkit.getPluginManager().callEvent(event) } return event } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getWorld("world") ?: error("world not loaded") val location = Location(world, 0.0, 120.0, 0.0, 0f, 0f) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = Bukkit.getPlayer(fakePlayer.uuid) ?: error("Player not found") player.isOp = true setModeset(player, "old") } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { setModeset(player, "old") player.gameMode = GameMode.SURVIVAL player.inventory.clear() player.inventory.setItemInMainHand(ItemStack(Material.ENDER_PEARL, 16)) } } test("cooldown 0 allows repeated throws and consumes an enderpearl in survival") { withConfig(cooldownSeconds = 0, showMessage = false) { val before = runSync { player.inventory.itemInMainHand.amount } val e1 = firePearlLaunchEvent(player) e1.isCancelled shouldBe true val after1 = runSync { player.inventory.itemInMainHand.amount } (before - after1) shouldBe 1 val e2 = firePearlLaunchEvent(player) e2.isCancelled shouldBe true val after2 = runSync { player.inventory.itemInMainHand.amount } (after1 - after2) shouldBe 1 } } test("cooldown blocks a second throw within the window and exposes remaining cooldown") { withConfig(cooldownSeconds = 5, showMessage = false) { val e1 = firePearlLaunchEvent(player) e1.isCancelled shouldBe true val remainingAfterFirst = runSync { module.getEnderpearlCooldown(player.uniqueId) } remainingAfterFirst shouldBeGreaterThan 0 val before2 = runSync { player.inventory.itemInMainHand.amount } val e2 = firePearlLaunchEvent(player) e2.isCancelled shouldBe true // Second throw attempt should not consume another pearl. val after2 = runSync { player.inventory.itemInMainHand.amount } before2 shouldBe after2 } } test("creative mode does not consume enderpearls") { withConfig(cooldownSeconds = 0, showMessage = false) { runSync { player.gameMode = GameMode.CREATIVE } val before = runSync { player.inventory.itemInMainHand.amount } val e1 = firePearlLaunchEvent(player) e1.isCancelled shouldBe true val after = runSync { player.inventory.itemInMainHand.amount } before shouldBe after } } test("no enderpearl item in either hand does not throw or consume") { withConfig(cooldownSeconds = 0, showMessage = false) { runSync { player.inventory.clear() } val e1 = firePearlLaunchEvent(player) e1.isCancelled shouldBe true runSync { player.inventory.itemInMainHand.type shouldBe Material.AIR } } } test("cooldown expires after real time and throw becomes allowed again") { withConfig(cooldownSeconds = 1, showMessage = false) { val e1 = firePearlLaunchEvent(player) e1.isCancelled shouldBe true // Wait slightly over a second to ensure wall-clock cooldown is over. delay(1200) val before2 = runSync { player.inventory.itemInMainHand.amount } val e2 = firePearlLaunchEvent(player) e2.isCancelled shouldBe true val after2 = runSync { player.inventory.itemInMainHand.amount } (before2 - after2) shouldBe 1 } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/FakePlayer.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.mojang.authlib.GameProfile import io.netty.channel.ChannelInboundHandlerAdapter import io.netty.channel.ChannelOutboundHandlerAdapter import io.netty.channel.embedded.EmbeddedChannel import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Entity import org.bukkit.entity.Player import org.bukkit.event.player.AsyncPlayerPreLoginEvent import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerPreLoginEvent import org.bukkit.event.player.PlayerQuitEvent import org.bukkit.plugin.java.JavaPlugin import xyz.jpenilla.reflectionremapper.ReflectionRemapper import java.lang.reflect.Method import java.net.InetAddress import java.net.InetSocketAddress import java.net.SocketAddress import java.net.UnknownHostException import java.util.* class FakePlayer(private val plugin: JavaPlugin) { val uuid: UUID = UUID.randomUUID() private val name: String = uuid.toString().substring(0, 16) private lateinit var serverPlayer: Any // NMS ServerPlayer instance private var bukkitPlayer: Player? = null private var networkConnection: Any? = null private var usedPlaceNewPlayer: Boolean = false private var tickTaskId: Int? = null private val isLegacy9 = !Reflector.versionIsNewerOrEqualTo(1, 10, 0) // 1.9.x and below private val isLegacy12 = !Reflector.versionIsNewerOrEqualTo(1, 13, 0) && Reflector.versionIsNewerOrEqualTo(1, 10, 0) private val legacyImpl9: LegacyFakePlayer9? = if (isLegacy9) LegacyFakePlayer9(plugin, uuid, name) else null private val legacyImpl12: LegacyFakePlayer12? = if (isLegacy12) LegacyFakePlayer12(plugin, uuid, name) else null private val reflectionRemapper: ReflectionRemapper = try { ReflectionRemapper.forReobfMappingsInPaperJar() } catch (e: Throwable) { plugin.logger.warning("Reflection mappings not found; using no-op remapper for legacy server.") ReflectionRemapper.noop() } // Helper function to load NMS classes using the appropriate class loader and remap names fun getNMSClass(name: String): Class<*> { // Remap the class name val remappedName = reflectionRemapper.remapClassName(name) // Get the NMS MinecraftServer from the Bukkit server val server = Bukkit.getServer() val craftServerClass = server.javaClass val getServerMethod = Reflector.getMethod(craftServerClass, "getServer") ?: throw NoSuchMethodException("Cannot find getServer method in ${craftServerClass.name}") val minecraftServer = Reflector.invokeMethod(getServerMethod, server) return Class.forName(remappedName, true, minecraftServer.javaClass.classLoader) } fun spawn(location: Location) { if (isLegacy9) { legacyImpl9!!.spawn(location) serverPlayer = legacyImpl9.entityPlayer ?: throw IllegalStateException("Legacy9 entity player not created.") bukkitPlayer = legacyImpl9.bukkitPlayer return } if (isLegacy12) { legacyImpl12!!.spawn(location) serverPlayer = legacyImpl12.entityPlayer ?: throw IllegalStateException("Legacy12 entity player not created.") bukkitPlayer = legacyImpl12.bukkitPlayer return } plugin.logger.info("Spawn: Starting") // Get the NMS WorldServer (ServerLevel) from the Bukkit world val world = location.world ?: throw IllegalArgumentException("Location has no world!") val craftWorldClass = world.javaClass val getHandleMethod = Reflector.getMethod(craftWorldClass, "getHandle") ?: throw NoSuchMethodException("Cannot find getHandle method in ${craftWorldClass.name}") val worldServer = Reflector.invokeMethod(getHandleMethod, world) val minecraftServer = getMinecraftServer() // Create a GameProfile for the fake player val gameProfile = GameProfile(uuid, name) // Get the ServerPlayer class and its constructor val minecraftServerClass = getNMSClass("net.minecraft.server.MinecraftServer") val serverPlayerClass = getNMSClass("net.minecraft.server.level.ServerPlayer") // Create a new instance of ServerPlayer (constructor signature varies by version) this.serverPlayer = createServerPlayer( serverPlayerClass, minecraftServerClass, minecraftServer, worldServer, gameProfile ) plugin.logger.info("Spawn: created serverPlayer") // Set up the connection for the ServerPlayer setupPlayerConnection(minecraftServer, worldServer) // Set the GameMode to SURVIVAL setPlayerGameMode("SURVIVAL", minecraftServer) setPlayerPosition(location) setPlayerRotation(0f, 0f) // Fire AsyncPlayerPreLoginEvent fireAsyncPlayerPreLoginEvent() // Add the player to the server's player list usedPlaceNewPlayer = addToPlayerList(minecraftServer) // Retrieve the Bukkit Player instance bukkitPlayer = Bukkit.getPlayer(uuid) ?: throw RuntimeException("Bukkit player with UUID $uuid not found!") // Fire PlayerJoinEvent firePlayerJoinEvent() // Notify other players and spawn the fake player if (!usedPlaceNewPlayer) { notifyPlayersOfJoin() spawnPlayerInWorld(worldServer, minecraftServer) } else if (bukkitPlayer?.world?.players?.contains(bukkitPlayer) != true) { spawnPlayerInWorld(worldServer, minecraftServer) } scheduleServerPlayerTick() plugin.logger.info("Spawn: completed successfully") } private fun setupPlayerConnection(minecraftServer: Any, worldServer: Any) { // Access ServerGamePacketListenerImpl class val serverGamePacketListenerImplClass = getNMSClass("net.minecraft.server.network.ServerGamePacketListenerImpl") // Create a new Connection object val connectionClass = getNMSClass("net.minecraft.network.Connection") val packetFlowClass = getNMSClass("net.minecraft.network.protocol.PacketFlow") val serverboundFieldName = reflectionRemapper.remapFieldName(packetFlowClass, "SERVERBOUND") val packetFlow = runCatching { Reflector.getEnumConstant(packetFlowClass, serverboundFieldName, "SERVERBOUND") }.getOrElse { val clientboundFieldName = reflectionRemapper.remapFieldName(packetFlowClass, "CLIENTBOUND") Reflector.getEnumConstant(packetFlowClass, clientboundFieldName, "CLIENTBOUND") } val connectionConstructor = connectionClass.getConstructor(packetFlowClass) val connection = connectionConstructor.newInstance(packetFlow) networkConnection = connection // Create a custom EmbeddedChannel with an overridden remoteAddress() val remoteAddress = InetSocketAddress("127.0.0.1", 9999) val embeddedChannel = EmbeddedChannel(ChannelInboundHandlerAdapter()) val pipeline = embeddedChannel.pipeline() if (pipeline.get("decoder") == null) { pipeline.addLast("decoder", ChannelInboundHandlerAdapter()) } if (pipeline.get("encoder") == null) { pipeline.addLast("encoder", ChannelOutboundHandlerAdapter()) } // Set the 'channel' field of 'connection' to the custom EmbeddedChannel val channelFieldName = reflectionRemapper.remapFieldName(connectionClass, "channel") val channelField = Reflector.getField(connectionClass, channelFieldName) channelField.isAccessible = true channelField.set(connection, embeddedChannel) // Set address field of connection val addressFieldName = reflectionRemapper.remapFieldName(connectionClass, "address") val addressField = Reflector.getField(connectionClass, addressFieldName) addressField.set(connection, remoteAddress) // Create a new ServerGamePacketListenerImpl instance (constructor signature varies by version) val serverPlayerClass = serverPlayer.javaClass val minecraftServerClass = getNMSClass("net.minecraft.server.MinecraftServer") val listenerInstance = createServerGamePacketListener( serverGamePacketListenerImplClass, minecraftServerClass, connectionClass, serverPlayerClass, minecraftServer, connection, serverPlayer ) // Set the listenerInstance to the player's 'connection' field val connectionFieldName = reflectionRemapper.remapFieldName(serverPlayerClass, "connection") val connectionField = Reflector.getField(serverPlayerClass, connectionFieldName) Reflector.setFieldValue(connectionField, serverPlayer, listenerInstance) val setListenerName = reflectionRemapper.remapMethodName( connectionClass, "setListener", listenerInstance.javaClass ) val setListenerMethod = Reflector.getMethodAssignable( connectionClass, setListenerName, listenerInstance.javaClass ) ?: Reflector.getMethodAssignable(connectionClass, "setListener", listenerInstance.javaClass) if (setListenerMethod != null) { Reflector.invokeMethod(setListenerMethod, connection, listenerInstance) } } private fun createServerGamePacketListener( listenerClass: Class<*>, minecraftServerClass: Class<*>, connectionClass: Class<*>, serverPlayerClass: Class<*>, minecraftServer: Any, connection: Any, serverPlayer: Any ): Any { val constructors = listenerClass.constructors.sortedBy { it.parameterCount } for (ctor in constructors) { val params = ctor.parameterTypes if (params.size < 3) continue if (!params[0].isAssignableFrom(minecraftServerClass)) continue if (!params[1].isAssignableFrom(connectionClass)) continue if (!params[2].isAssignableFrom(serverPlayerClass)) continue val args = ArrayList() args.add(minecraftServer) args.add(connection) args.add(serverPlayer) var supported = true for (i in 3 until params.size) { val param = params[i] when (param.simpleName) { "CommonListenerCookie" -> args.add(createCommonListenerCookie(param, serverPlayer)) else -> { supported = false break } } } if (!supported) continue return ctor.newInstance(*args.toTypedArray()) } throw NoSuchMethodException("No compatible ServerGamePacketListenerImpl constructor found for ${listenerClass.name}") } private fun createCommonListenerCookie(cookieClass: Class<*>, serverPlayer: Any): Any { val getProfileName = reflectionRemapper.remapMethodName(serverPlayer.javaClass, "getGameProfile") val getProfileMethod = Reflector.getMethod(serverPlayer.javaClass, getProfileName) ?: Reflector.getMethod(serverPlayer.javaClass, "getGameProfile") ?: throw NoSuchMethodException("getGameProfile not found in ${serverPlayer.javaClass.name}") val gameProfile = Reflector.invokeMethod(getProfileMethod, serverPlayer) val remappedName = reflectionRemapper.remapMethodName( cookieClass, "createInitial", GameProfile::class.java, Boolean::class.javaPrimitiveType ) val method = Reflector.getMethod(cookieClass, remappedName, "GameProfile", "boolean") ?: Reflector.getMethod(cookieClass, "createInitial", "GameProfile", "boolean") ?: throw NoSuchMethodException("createInitial not found in ${cookieClass.name}") return Reflector.invokeMethod(method, null, gameProfile, false) } private fun createServerPlayer( serverPlayerClass: Class<*>, minecraftServerClass: Class<*>, minecraftServer: Any, worldServer: Any, gameProfile: GameProfile ): Any { val constructors = serverPlayerClass.constructors.sortedBy { it.parameterCount } for (ctor in constructors) { val params = ctor.parameterTypes if (params.size < 3) continue if (!params[0].isAssignableFrom(minecraftServerClass)) continue if (!params[1].isAssignableFrom(worldServer.javaClass)) continue if (params[2] != GameProfile::class.java) continue val args = ArrayList() args.add(minecraftServer) args.add(worldServer) args.add(gameProfile) var supported = true for (i in 3 until params.size) { val param = params[i] when (param.simpleName) { "ProfilePublicKey" -> args.add(null) "ClientInformation" -> args.add(createDefaultClientInformation(param)) else -> { supported = false break } } } if (!supported) continue return ctor.newInstance(*args.toTypedArray()) } throw NoSuchMethodException("No compatible ServerPlayer constructor found for ${serverPlayerClass.name}") } private fun createDefaultClientInformation(clientInfoClass: Class<*>): Any { val remappedName = reflectionRemapper.remapMethodName(clientInfoClass, "createDefault") val method = Reflector.getMethod(clientInfoClass, remappedName) ?: Reflector.getMethod(clientInfoClass, "createDefault") ?: throw NoSuchMethodException("createDefault not found in ${clientInfoClass.name}") return Reflector.invokeMethod(method, null) } private fun setPlayerGameMode(gameModeName: String, minecraftServer: Any) { val gameModeClass = getNMSClass("net.minecraft.world.level.GameType") val gameModeFieldName = reflectionRemapper.remapFieldName(gameModeClass, gameModeName) val gameModeField = Reflector.getField(gameModeClass, gameModeFieldName) val gameMode = gameModeField.get(null) val setGameModeMethodName = reflectionRemapper.remapMethodName( serverPlayer.javaClass, "setGameMode", gameModeClass ) val setGameModeMethod = serverPlayer.javaClass.getMethod(setGameModeMethodName, gameModeClass) setGameModeMethod.invoke(serverPlayer, gameMode) } private fun setPlayerPosition(location: Location) { val entityClass = getNMSClass("net.minecraft.world.entity.Entity") val setPosMethodName = reflectionRemapper.remapMethodName( entityClass, "setPos", Double::class.javaPrimitiveType, Double::class.javaPrimitiveType, Double::class.javaPrimitiveType ) val setPosMethod = checkNotNull( Reflector.getMethod( entityClass, setPosMethodName, "double", "double", "double" ) ) setPosMethod.invoke(serverPlayer, location.x, location.y, location.z) } private fun setPlayerRotation(xRot: Float, yRot: Float) { val entityClass = getNMSClass("net.minecraft.world.entity.Entity") val xRotFieldName = reflectionRemapper.remapFieldName(entityClass, "xRot") val xRotField = Reflector.getField(entityClass, xRotFieldName) xRotField.setFloat(serverPlayer, xRot) val yRotFieldName = reflectionRemapper.remapFieldName(entityClass, "yRot") val yRotField = Reflector.getField(entityClass, yRotFieldName) yRotField.setFloat(serverPlayer, yRot) } private fun fireAsyncPlayerPreLoginEvent() { try { val ipAddress = InetAddress.getByName("127.0.0.1") @Suppress("DEPRECATION") // Legacy constructor kept for older server compatibility in tests. val asyncPreLoginEvent = AsyncPlayerPreLoginEvent(name, ipAddress, uuid) Thread { Bukkit.getPluginManager().callEvent(asyncPreLoginEvent) }.start() } catch (e: UnknownHostException) { plugin.logger.severe("Spawn: UnknownHostException - ${e.message}") e.printStackTrace() } } private fun addToPlayerList(minecraftServer: Any): Boolean { val playerList = getPlayerList(minecraftServer) // Add the player to the PlayerList val playerListClass = getNMSClass("net.minecraft.server.players.PlayerList") val placeMethodName = reflectionRemapper.remapMethodName(playerListClass, "placeNewPlayer") val connection = checkNotNull(networkConnection) { "Connection not initialised" } val placeMethodWithCookie = Reflector.getMethodAssignable( playerListClass, placeMethodName, connection.javaClass, serverPlayer.javaClass, null ) ?: Reflector.getMethodAssignable( playerListClass, "placeNewPlayer", connection.javaClass, serverPlayer.javaClass, null ) if (placeMethodWithCookie != null && placeMethodWithCookie.parameterTypes.size == 3) { val cookieClass = placeMethodWithCookie.parameterTypes[2] val cookie = createCommonListenerCookie(cookieClass, serverPlayer) placeMethodWithCookie.invoke(playerList, connection, serverPlayer, cookie) return true } val placeMethod = Reflector.getMethodAssignable( playerListClass, placeMethodName, connection.javaClass, serverPlayer.javaClass ) ?: Reflector.getMethodAssignable( playerListClass, "placeNewPlayer", connection.javaClass, serverPlayer.javaClass ) if (placeMethod != null) { placeMethod.invoke(playerList, connection, serverPlayer) return true } val loadMethodName = reflectionRemapper.remapMethodName(playerListClass, "load", serverPlayer.javaClass) val loadMethod = playerListClass.methods.firstOrNull { method -> method.name == loadMethodName && method.parameterCount == 1 && method.parameterTypes[0].isAssignableFrom(serverPlayer.javaClass) } if (loadMethod != null) { Reflector.invokeMethod(loadMethod, playerList, serverPlayer) val playersFieldName = reflectionRemapper.remapFieldName(playerListClass, "players") val playersField = playerListClass.getDeclaredField(playersFieldName) playersField.isAccessible = true @Suppress("UNCHECKED_CAST") // Reflection into NMS collection; types vary by version. val players = playersField.get(playerList) as MutableList players.add(serverPlayer) // Add player to the UUID map val playersByUUIDField = Reflector.getMapFieldWithTypes( playerListClass, UUID::class.java, serverPlayer.javaClass ) @Suppress("UNCHECKED_CAST") // Reflection into NMS map; types vary by version. val playerByUUID = Reflector.getFieldValue(playersByUUIDField, playerList) as MutableMap playerByUUID[uuid] = serverPlayer return false } throw NoSuchMethodException("No compatible PlayerList add method found for ${playerListClass.name}") } private fun firePlayerJoinEvent() { val joinMessage = "$name joined the game" val playerJoinEvent = PlayerJoinEvent(bukkitPlayer!!, joinMessage) Bukkit.getPluginManager().callEvent(playerJoinEvent) } private fun notifyPlayersOfJoin() { if (Bukkit.getOnlinePlayers().isEmpty()) return val packet = runCatching { createLegacyPlayerInfoPacket() }.getOrNull() ?: runCatching { createPlayerInfoUpdatePacket() }.getOrNull() ?: return sendPacket(packet) } private fun spawnPlayerInWorld(worldServer: Any, minecraftServer: Any) { // Add the player to the world val worldServerClass = worldServer.javaClass val addNewPlayerMethodName = reflectionRemapper.remapMethodName( worldServerClass, "addNewPlayer", serverPlayer.javaClass ) val addNewPlayerMethod = Reflector.getMethodAssignable( worldServerClass, addNewPlayerMethodName, serverPlayer.javaClass ) ?: Reflector.getMethodAssignable(worldServerClass, "addNewPlayer", serverPlayer.javaClass) ?: Reflector.getMethodAssignable(worldServerClass, "addPlayer", serverPlayer.javaClass) ?: Reflector.getMethodAssignable(worldServerClass, "addFreshEntity", serverPlayer.javaClass) ?: Reflector.getMethodAssignable(worldServerClass, "addEntity", serverPlayer.javaClass) if (addNewPlayerMethod != null) { addNewPlayerMethod.invoke(worldServer, serverPlayer) } else { plugin.logger.warning("Spawn: Could not find a world add method for ${worldServerClass.name}") } // Send world info to the player val minecraftServerClass = getNMSClass("net.minecraft.server.MinecraftServer") runCatching { val getStatusMethodName = reflectionRemapper.remapMethodName(minecraftServerClass, "getStatus") val getStatusMethod = Reflector.getMethod(minecraftServerClass, getStatusMethodName) val status = Reflector.invokeMethod(getStatusMethod!!, minecraftServer) val sendServerStatusMethodName = reflectionRemapper.remapMethodName( serverPlayer.javaClass, "sendServerStatus", status.javaClass ) val sendServerStatusMethod = Reflector.getMethod( serverPlayer.javaClass, sendServerStatusMethodName, status.javaClass.simpleName ) ?: Reflector.getMethod(serverPlayer.javaClass, "sendServerStatus", status.javaClass.simpleName) if (sendServerStatusMethod != null) { sendServerStatusMethod.invoke(serverPlayer, status) } } // Send ClientboundAddPlayerPacket to all players runCatching { val clientboundAddPlayerPacketClass = getNMSClass("net.minecraft.network.protocol.game.ClientboundAddPlayerPacket") val playerClassName = getNMSClass("net.minecraft.world.entity.player.Player") // ServerPlayer is subclass of Player val clientboundAddPlayerPacketConstructor = clientboundAddPlayerPacketClass.getConstructor(playerClassName) val packet = clientboundAddPlayerPacketConstructor.newInstance(serverPlayer) sendPacket(packet) } } private fun createLegacyPlayerInfoPacket(): Any { val clientboundPlayerInfoPacketClass = getNMSClass("net.minecraft.network.protocol.game.ClientboundPlayerInfoPacket") val actionClass = getNMSClass("net.minecraft.network.protocol.game.ClientboundPlayerInfoPacket\$Action") val addPlayerFieldName = reflectionRemapper.remapFieldName(actionClass, "ADD_PLAYER") val addPlayerAction = actionClass.getDeclaredField(addPlayerFieldName).get(null) val clientboundPlayerInfoPacketConstructor = clientboundPlayerInfoPacketClass.getConstructor( actionClass, Collection::class.java ) return clientboundPlayerInfoPacketConstructor.newInstance( addPlayerAction, listOf(serverPlayer) ) } private fun createPlayerInfoUpdatePacket(): Any { val packetClass = getNMSClass("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket") val actionClass = getNMSClass("net.minecraft.network.protocol.game.ClientboundPlayerInfoUpdatePacket\$Action") val addPlayerFieldName = reflectionRemapper.remapFieldName(actionClass, "ADD_PLAYER") val addPlayerAction = actionClass.getDeclaredField(addPlayerFieldName).get(null) val createInitMethodName = reflectionRemapper.remapMethodName( packetClass, "createPlayerInitializing", serverPlayer.javaClass ) val createInitMethod = Reflector.getMethodAssignable( packetClass, createInitMethodName, serverPlayer.javaClass ) ?: Reflector.getMethodAssignable(packetClass, "createPlayerInitializing", serverPlayer.javaClass) if (createInitMethod != null) { return Reflector.invokeMethod(createInitMethod, null, serverPlayer) } val constructor = packetClass.getConstructor(EnumSet::class.java, Collection::class.java) val enumSetNoneOf = EnumSet::class.java.getMethod("noneOf", Class::class.java) @Suppress("UNCHECKED_CAST") val actions = enumSetNoneOf.invoke(null, actionClass) as MutableSet actions.add(addPlayerAction) return constructor.newInstance(actions, listOf(serverPlayer)) } private fun sendPacket(packet: Any) { // Get the Packet class val packetClass = getNMSClass("net.minecraft.network.protocol.Packet") // Send packet to all online players Bukkit.getOnlinePlayers().forEach { player -> val craftPlayerClass = player.javaClass val getHandleMethodName = reflectionRemapper.remapMethodName(craftPlayerClass, "getHandle") val getHandleMethod = craftPlayerClass.getMethod(getHandleMethodName) val entityPlayer = getHandleMethod.invoke(player) val connection = getConnection(entityPlayer) val sendMethodName = reflectionRemapper.remapMethodName(connection.javaClass, "send", packetClass) val sendMethod = connection.javaClass.getMethod(sendMethodName, packetClass) sendMethod.invoke(connection, packet) } } fun getConnection(serverPlayer: Any): Any { if (isLegacy9) return legacyImpl9!!.getConnection(serverPlayer) if (isLegacy12) return legacyImpl12!!.getConnection(serverPlayer) val entityPlayerClass = serverPlayer.javaClass val connectionFieldName = reflectionRemapper.remapFieldName(entityPlayerClass, "connection") val connectionField = Reflector.getField(entityPlayerClass, connectionFieldName) if (connectionField != null) return connectionField.get(serverPlayer) val legacyField = Reflector.getField(entityPlayerClass, "playerConnection") return legacyField?.get(serverPlayer) ?: error("No connection field on ${entityPlayerClass.name}") } fun removePlayer() { tickTaskId?.let { Bukkit.getScheduler().cancelTask(it) } if (isLegacy9) { legacyImpl9!!.removePlayer() return } if (isLegacy12) { legacyImpl12!!.removePlayer() return } // Fire PlayerQuitEvent val quitMessage = "§e$name left the game" val playerQuitEvent = PlayerQuitEvent(bukkitPlayer!!, quitMessage) Bukkit.getPluginManager().callEvent(playerQuitEvent) // Disconnect the player bukkitPlayer!!.kickPlayer(quitMessage) // Remove the player from the world /* val removeMethodName = reflectionRemapper.remapMethodName( serverPlayer.javaClass, "remove" ) val removeMethod = serverPlayer.javaClass.getMethod(removeMethodName) removeMethod.invoke(serverPlayer) */ // Remove from playerList if still present and not already removed runCatching { val playerList = getPlayerList(getMinecraftServer()) if (!isEntityRemoved(serverPlayer) && isPlayerListed(playerList)) { val removePlayerMethodName = reflectionRemapper.remapMethodName( playerList.javaClass, "remove", serverPlayer.javaClass ) val removePlayerMethod = playerList.javaClass.getMethod(removePlayerMethodName, serverPlayer.javaClass) removePlayerMethod.invoke(playerList, serverPlayer) } } // Close the connection properly val connection = getConnection(serverPlayer) val disconnectMethodName = reflectionRemapper.remapMethodName( connection.javaClass, "disconnect", getNMSClass("net.minecraft.network.chat.Component") ) val disconnectMethod = connection.javaClass.getMethod(disconnectMethodName, getNMSClass("net.minecraft.network.chat.Component")) val quitMessageNoColour = "$name left the game" val disconnectMessage = getNMSComponent(quitMessageNoColour) disconnectMethod.invoke(connection, disconnectMessage) } private fun scheduleServerPlayerTick() { if (isLegacy9 || isLegacy12) return val serverPlayerClass = serverPlayer.javaClass val tickMethod = resolveServerPlayerTickMethod(serverPlayerClass) val baseTickMethod = resolveBaseTickMethod(serverPlayerClass) val getRemainingFireTicksMethod = runCatching { val entityClass = getNMSClass("net.minecraft.world.entity.Entity") val remapped = reflectionRemapper.remapMethodName(entityClass, "getRemainingFireTicks") Reflector.getMethod(entityClass, remapped) ?: Reflector.getMethod(entityClass, "getRemainingFireTicks") }.getOrNull() tickTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, Runnable { val remainingFireTicks = if (getRemainingFireTicksMethod != null) { runCatching { getRemainingFireTicksMethod.invoke(serverPlayer) as Int }.getOrNull() } else { null } if (remainingFireTicks != null && remainingFireTicks > 0) { val player = bukkitPlayer val inWater = player != null && ( player.location.block.type == Material.WATER || player.eyeLocation.block.type == Material.WATER ) if (inWater && tickMethod != null) { runCatching { tickMethod.invoke(serverPlayer) } return@Runnable } if (baseTickMethod != null) { runCatching { baseTickMethod.invoke(serverPlayer) } return@Runnable } } if (tickMethod != null) { runCatching { tickMethod.invoke(serverPlayer) } } else if (baseTickMethod != null) { runCatching { baseTickMethod.invoke(serverPlayer) } } }, 1L, 1L) } private fun resolveServerPlayerTickMethod(serverPlayerClass: Class<*>): Method? { val candidateNames = listOf("doTick", "tick") for (name in candidateNames) { val remapped = reflectionRemapper.remapMethodName(serverPlayerClass, name) val method = Reflector.getMethod(serverPlayerClass, remapped) ?: Reflector.getMethod(serverPlayerClass, name) if (method != null && method.parameterCount == 0) { method.isAccessible = true return method } } val baseTickMethod = resolveBaseTickMethod(serverPlayerClass) if (baseTickMethod != null) { return baseTickMethod } val fallback = serverPlayerClass.methods.firstOrNull { method -> method.parameterCount == 0 && method.returnType == Void.TYPE && method.name.lowercase().contains("tick") } ?: serverPlayerClass.methods.firstOrNull { method -> method.parameterCount == 0 && method.returnType == Void.TYPE } fallback?.isAccessible = true return fallback } private fun resolveBaseTickMethod(serverPlayerClass: Class<*>): Method? { val entityClass = runCatching { getNMSClass("net.minecraft.world.entity.Entity") }.getOrNull() val candidateNames = buildList { entityClass?.let { add(reflectionRemapper.remapMethodName(it, "baseTick")) } add("baseTick") }.distinct() for (name in candidateNames) { val method = (serverPlayerClass.declaredMethods + serverPlayerClass.methods).firstOrNull { candidate -> candidate.name == name && candidate.parameterCount == 0 } ?: entityClass?.let { clazz -> (clazz.declaredMethods + clazz.methods).firstOrNull { candidate -> candidate.name == name && candidate.parameterCount == 0 } } if (method != null) { method.isAccessible = true return method } } return null } private fun getNMSComponent(message: String): Any { // Convert a String to an NMS Component val componentClass = getNMSClass("net.minecraft.network.chat.Component") val literalName = reflectionRemapper.remapMethodName(componentClass, "literal", String::class.java) val componentMethod = checkNotNull(Reflector.getMethod(componentClass, literalName, "String")) return componentMethod.invoke(null, message) } private fun getMinecraftServer(): Any { val server = Bukkit.getServer() val craftServerClass = server.javaClass val getServerMethod = Reflector.getMethod(craftServerClass, "getServer") ?: throw NoSuchMethodException("Cannot find getServer method in ${craftServerClass.name}") return Reflector.invokeMethod(getServerMethod, server) } private fun getPlayerList(minecraftServer: Any): Any { val playerListFieldName = reflectionRemapper.remapMethodName(minecraftServer.javaClass, "getPlayerList") val playerListMethod = checkNotNull(Reflector.getMethod(minecraftServer.javaClass, playerListFieldName)) return Reflector.invokeMethod(playerListMethod, minecraftServer) } private fun isPlayerListed(playerList: Any): Boolean { val playerListClass = getNMSClass("net.minecraft.server.players.PlayerList") return runCatching { val playersByUUIDField = Reflector.getMapFieldWithTypes( playerListClass, UUID::class.java, serverPlayer.javaClass ) @Suppress("UNCHECKED_CAST") // Reflection into NMS map; types vary by version. val playerByUUID = Reflector.getFieldValue(playersByUUIDField, playerList) as Map playerByUUID.containsKey(uuid) }.getOrElse { val getPlayerMethodName = reflectionRemapper.remapMethodName(playerListClass, "getPlayer", UUID::class.java) val getPlayerMethod = Reflector.getMethodAssignable( playerListClass, getPlayerMethodName, UUID::class.java ) ?: Reflector.getMethodAssignable(playerListClass, "getPlayer", UUID::class.java) if (getPlayerMethod != null) { Reflector.invokeMethod(getPlayerMethod, playerList, uuid) != null } else { true } } } private fun isEntityRemoved(entity: Any): Boolean { val entityClass = getNMSClass("net.minecraft.world.entity.Entity") val isRemovedMethodName = reflectionRemapper.remapMethodName(entityClass, "isRemoved") val isRemovedMethod = Reflector.getMethod(entityClass, isRemovedMethodName) ?: Reflector.getMethod(entityClass, "isRemoved") if (isRemovedMethod != null) { return Reflector.invokeMethod(isRemovedMethod, entity) } return runCatching { val removedFieldName = reflectionRemapper.remapFieldName(entityClass, "removed") val removedField = Reflector.getField(entityClass, removedFieldName) removedField.getBoolean(entity) }.getOrDefault(false) } fun attack(bukkitEntity: Entity) { attackCompat(checkNotNull(bukkitPlayer), bukkitEntity) } fun doBlocking() { if (isLegacy9 || isLegacy12) { // Legacy blocking: ensure sword in hand + shield in offhand, then raise offhand. bukkitPlayer!!.inventory.setItemInMainHand(org.bukkit.inventory.ItemStack(Material.DIAMOND_SWORD)) if (bukkitPlayer!!.inventory.itemInOffHand.type != Material.SHIELD) { bukkitPlayer!!.inventory.setItemInOffHand(org.bukkit.inventory.ItemStack(Material.SHIELD)) } bukkitPlayer!!.updateInventory() if (isLegacy12) legacyImpl12?.startUsingOffhand() return } bukkitPlayer!!.inventory.setItemInMainHand(org.bukkit.inventory.ItemStack(Material.SHIELD)) val livingEntityClass = getNMSClass("net.minecraft.world.entity.LivingEntity") // Start using item (simulate blocking) val interactionHandClass = getNMSClass("net.minecraft.world.InteractionHand") val mainHandFieldName = reflectionRemapper.remapFieldName(interactionHandClass, "MAIN_HAND") val mainHandField = interactionHandClass.getDeclaredField(mainHandFieldName) val mainHand = mainHandField.get(null) val startUsingItemMethodName = reflectionRemapper.remapMethodName( livingEntityClass, "startUsingItem", interactionHandClass ) val startUsingItemMethod = checkNotNull( Reflector.getMethod(livingEntityClass, startUsingItemMethodName, interactionHandClass.simpleName) ) Reflector.invokeMethod(startUsingItemMethod, serverPlayer, mainHand) // Manually set useItemRemaining field to simulate blocking val useItemRemainingFieldName = reflectionRemapper.remapFieldName(livingEntityClass, "useItemRemaining") val useItemRemainingField = livingEntityClass.getDeclaredField(useItemRemainingFieldName) useItemRemainingField.isAccessible = true useItemRemainingField.setInt(serverPlayer, 200) } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/FireAspectOverdamageIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XEnchantment import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeLessThan import io.kotest.matchers.ints.shouldBeGreaterThan import io.kotest.matchers.ints.shouldBeLessThanOrEqual import io.kotest.matchers.ints.shouldBeExactly import io.kotest.matchers.shouldBe import io.kotest.assertions.withClue import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.AttributeModifier import org.bukkit.entity.Entity import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.potion.PotionEffect import org.bukkit.potion.PotionEffectType import org.bukkit.util.Vector import kotlinx.coroutines.delay import java.util.concurrent.Callable import kotlin.math.abs @OptIn(ExperimentalKotest::class) class FireAspectOverdamageIntegrationTest : FunSpec({ val plugin = JavaPlugin.getPlugin(OCMTestMain::class.java) extensions(MainThreadDispatcherExtension(plugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(plugin, Callable { action() null }).get() } } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } val isLegacyServer = !kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector.versionIsNewerOrEqualTo(1, 13, 0) fun needsAttackWarmup(attacker: Player): Boolean = isLegacyServer data class AttackSample( val cancelled: Boolean, val damage: Double, val finalDamage: Double, val noDamageTicks: Int, val lastDamage: Double ) data class FireTickSample(val cancelled: Boolean, val finalDamage: Double) suspend fun waitForFireTick(samples: List, timeoutTicks: Long = 120) { repeat(timeoutTicks.toInt()) { if (samples.isNotEmpty()) return delayTicks(1) } error("Expected a fire tick event within $timeoutTicks ticks, but none fired.") } fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun equip(player: Player, item: ItemStack) { prepareWeapon(item) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() if (attackSpeedAttribute != null) { player.getAttribute(attackSpeedAttribute)?.baseValue = 1000.0 } if (isLegacyServer) { // Legacy fake players can miss item-based attack damage modifiers until after the first swing. // Force a stable baseline so overdamage tests are not dependent on attribute refresh timing. val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attribute = attackDamageAttribute?.let { player.getAttribute(it) } if (attribute != null) { attribute.baseValue = when (item.type) { Material.DIAMOND_SWORD -> 7.0 else -> attribute.baseValue } } } player.inventory.setItemInMainHand(item) player.updateInventory() } fun spawnPlayer(location: Location): Pair { val fake = FakePlayer(plugin) fake.spawn(location) val player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "old") setPlayerData(player.uniqueId, playerData) return fake to player } fun spawnVictim(location: Location): LivingEntity { val world = location.world ?: error("World missing for victim spawn") return world.spawn(location, org.bukkit.entity.Zombie::class.java).apply { maximumNoDamageTicks = 100 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } fun prepareVictimState(victim: LivingEntity, maxHealthOverride: Double? = null) { if (maxHealthOverride != null) { val maxHealthAttribute = XAttribute.MAX_HEALTH.get() if (maxHealthAttribute != null) { victim.getAttribute(maxHealthAttribute)?.baseValue = maxHealthOverride } else { victim.maxHealth = maxHealthOverride } } victim.maximumNoDamageTicks = 100 victim.noDamageTicks = 0 victim.lastDamage = 0.0 victim.fireTicks = 0 victim.isInvulnerable = false victim.health = victim.maxHealth } fun ensureBurning(victim: LivingEntity, minTicks: Int = 200) { if (victim.fireTicks < minTicks) { victim.fireTicks = minTicks } } fun requireInvulnerabilityWindow(victim: LivingEntity) { val maxTicks = victim.maximumNoDamageTicks if (victim.noDamageTicks.toDouble() <= maxTicks / 2.0) { error( "Expected to still be inside the invulnerability window, but noDamageTicks=" + "${victim.noDamageTicks} maxNoDamageTicks=$maxTicks" ) } } fun applyProtectionArmour(entity: LivingEntity) { val protection = XEnchantment.PROTECTION.get() val armour = arrayOf( ItemStack(Material.DIAMOND_BOOTS), ItemStack(Material.DIAMOND_LEGGINGS), ItemStack(Material.DIAMOND_CHESTPLATE), ItemStack(Material.DIAMOND_HELMET) ) if (protection != null) { armour.forEach { it.addUnsafeEnchantment(protection, 4) } } if (entity is Player) { entity.inventory.setArmorContents(armour) return } entity.equipment?.armorContents = armour } fun applyFireProtectionArmour(entity: LivingEntity) { val fireProtection = XEnchantment.FIRE_PROTECTION.get() val armour = arrayOf( ItemStack(Material.DIAMOND_BOOTS), ItemStack(Material.DIAMOND_LEGGINGS), ItemStack(Material.DIAMOND_CHESTPLATE), ItemStack(Material.DIAMOND_HELMET) ) if (fireProtection != null) { armour.forEach { it.addUnsafeEnchantment(fireProtection, 4) } } if (entity is Player) { entity.inventory.setArmorContents(armour) return } entity.equipment?.armorContents = armour } fun applyFireResistance(entity: LivingEntity, durationTicks: Int = 20 * 60) { entity.addPotionEffect(PotionEffect(PotionEffectType.FIRE_RESISTANCE, durationTicks, 0), true) } fun disableAiIfPossible(entity: LivingEntity) { runCatching { val method = entity.javaClass.methods.firstOrNull { m -> m.name == "setAI" && m.parameterTypes.size == 1 && (m.parameterTypes[0] == java.lang.Boolean.TYPE || m.parameterTypes[0] == java.lang.Boolean::class.java) } ?: return method.invoke(entity, false) } } fun stabilise(entity: Entity, location: Location) { entity.fallDistance = 0.0f entity.teleport(location) entity.velocity = Vector(0, 0, 0) } data class BlockTypeSnapshot(val location: Location, val type: Material) fun placeWaterColumn(world: org.bukkit.World, base: Location, height: Int = 2): List { val x = base.blockX val y = base.blockY val z = base.blockZ val snapshots = mutableListOf() repeat(height) { dy -> val block = world.getBlockAt(x, y + dy, z) snapshots.add(BlockTypeSnapshot(block.location, block.type)) block.type = Material.WATER } return snapshots } fun restoreBlocks(snapshots: List) { snapshots.forEach { snap -> val world = snap.location.world ?: return@forEach world.getBlockAt(snap.location.blockX, snap.location.blockY, snap.location.blockZ).type = snap.type } } suspend fun countSuccessfulAttacks( attacker: Player, victim: LivingEntity, weapon: ItemStack, attempts: Int, tickDelay: Long ): Int { var count = 0 val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onDamage(event: EntityDamageByEntityEvent) { if (event.entity.uniqueId != victim.uniqueId) return if (event.damager.uniqueId != attacker.uniqueId) return if (event.cause != EntityDamageEvent.DamageCause.ENTITY_ATTACK) return if (!event.isCancelled) { count++ } } } Bukkit.getPluginManager().registerEvents(listener, plugin) try { equip(attacker, weapon) repeat(attempts) { runSync { attackCompat(attacker, victim) } delayTicks(tickDelay) } } finally { HandlerList.unregisterAll(listener) } return count } suspend fun collectFireTickDamages( victim: LivingEntity, expectedCount: Int, trigger: suspend () -> Unit ): List { val samples = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onFireTick(event: EntityDamageEvent) { if (event.entity.uniqueId != victim.uniqueId) return val cause = event.cause if (cause != EntityDamageEvent.DamageCause.FIRE_TICK && cause != EntityDamageEvent.DamageCause.FIRE ) return samples.add(FireTickSample(event.isCancelled, event.finalDamage)) } } Bukkit.getPluginManager().registerEvents(listener, plugin) try { trigger() repeat(200) { if (samples.size >= expectedCount) return@repeat delayTicks(1) } } finally { HandlerList.unregisterAll(listener) } if (samples.size < expectedCount) { error("Expected $expectedCount fire tick events, got ${samples.size}") } val nonCancelled = samples.filterNot { it.cancelled } if (nonCancelled.size < expectedCount) { error( "Expected $expectedCount non-cancelled fire tick events, got ${nonCancelled.size} " + "(cancelled=${samples.count { it.cancelled }})" ) } return nonCancelled.take(expectedCount).map { it.finalDamage } } fun snapshotOverdamageState( attacker: Player, victim: LivingEntity, attackSamples: List, fireTickSamples: List ): String { var snapshot = "" runSync { val meta = victim.getMetadata("ocm-last-damage") .joinToString(prefix = "[", postfix = "]") { m -> "${m.owningPlugin?.name ?: "?"}=${runCatching { m.asDouble() }.getOrNull()}" } val attackDetails = attackSamples.joinToString(prefix = "[", postfix = "]") { "{c=${it.cancelled}, dmg=${it.damage}, final=${it.finalDamage}, ndt=${it.noDamageTicks}, ld=${it.lastDamage}}" } snapshot = "attacks(total=${attackSamples.size}, ok=${attackSamples.count { !it.cancelled }}, " + "cancelled=${attackSamples.count { it.cancelled }}, details=$attackDetails) " + "fireTicks(total=${fireTickSamples.size}, ok=${fireTickSamples.count { !it.cancelled }}, " + "cancelled=${fireTickSamples.count { it.cancelled }}) " + "attacker(onGround=${attacker.isOnGround}, fallDistance=${attacker.fallDistance}, " + "sprinting=${attacker.isSprinting}, velocity=${attacker.velocity}) " + "victim(noDamageTicks=${victim.noDamageTicks}, maxNoDamageTicks=${victim.maximumNoDamageTicks}, " + "lastDamage=${victim.lastDamage}, health=${victim.health}/${victim.maxHealth}, " + "fireTicks=${victim.fireTicks}, meta=$meta)" } return snapshot } test("fire aspect does not bypass invulnerability cancellation") { if (!Reflector.versionIsNewerOrEqualTo(1, 12, 0)) return@test val attackSamples = mutableListOf() val fireTickSamples = mutableListOf() lateinit var attacker: Player var victim: LivingEntity? = null var fakeAttacker: FakePlayer? = null val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { attackSamples.add( AttackSample( cancelled = event.isCancelled, damage = event.damage, finalDamage = event.finalDamage, noDamageTicks = currentVictim.noDamageTicks, lastDamage = currentVictim.lastDamage ) ) } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onFireTick(event: EntityDamageEvent) { val cause = event.cause val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && (cause == EntityDamageEvent.DamageCause.FIRE_TICK || cause == EntityDamageEvent.DamageCause.FIRE) ) { fireTickSamples.add(FireTickSample(event.isCancelled, event.finalDamage)) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(checkNotNull(victim)) Bukkit.getPluginManager().registerEvents(listener, plugin) val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) } // Vanilla 1.12 scales attack damage by cooldown *before* the Bukkit damage event is fired. // Fake players can start with an incomplete cooldown, so wait a few ticks to make the first hit stable. if (needsAttackWarmup(attacker)) { delayTicks(6) } runSync { attackCompat(attacker, checkNotNull(victim)) } delayTicks(2) runSync { val fireEvent = EntityDamageEvent( checkNotNull(victim), EntityDamageEvent.DamageCause.FIRE_TICK, 1.0 ) Bukkit.getPluginManager().callEvent(fireEvent) } waitForFireTick(fireTickSamples, timeoutTicks = 5) runSync { requireInvulnerabilityWindow(checkNotNull(victim)) } runSync { attackCompat(attacker, checkNotNull(victim)) } delayTicks(2) val state = snapshotOverdamageState(attacker, checkNotNull(victim), attackSamples, fireTickSamples) withClue(state) { attackSamples.count { !it.cancelled }.shouldBeExactly(1) } } finally { HandlerList.unregisterAll(listener) runSync { fakeAttacker?.removePlayer() victim?.remove() } } } test("fire tick does not clear overdamage baseline") { val attackSamples = mutableListOf() val fireTickSamples = mutableListOf() lateinit var attacker: Player var victim: LivingEntity? = null var fakeAttacker: FakePlayer? = null val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { attackSamples.add( AttackSample( cancelled = event.isCancelled, damage = event.damage, finalDamage = event.finalDamage, noDamageTicks = currentVictim.noDamageTicks, lastDamage = currentVictim.lastDamage ) ) } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onFireTick(event: EntityDamageEvent) { val cause = event.cause val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && (cause == EntityDamageEvent.DamageCause.FIRE_TICK || cause == EntityDamageEvent.DamageCause.FIRE) ) { fireTickSamples.add(FireTickSample(event.isCancelled, event.finalDamage)) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(checkNotNull(victim)) Bukkit.getPluginManager().registerEvents(listener, plugin) val weapon = ItemStack(Material.DIAMOND_SWORD) equip(attacker, weapon) } if (needsAttackWarmup(attacker)) { delayTicks(6) } runSync { attackCompat(attacker, checkNotNull(victim)) } delayTicks(2) runSync { val fireEvent = EntityDamageEvent( checkNotNull(victim), EntityDamageEvent.DamageCause.FIRE_TICK, 1.0 ) Bukkit.getPluginManager().callEvent(fireEvent) } waitForFireTick(fireTickSamples, timeoutTicks = 5) runSync { requireInvulnerabilityWindow(checkNotNull(victim)) } runSync { attackCompat(attacker, checkNotNull(victim)) } delayTicks(2) val state = snapshotOverdamageState(attacker, checkNotNull(victim), attackSamples, fireTickSamples) withClue(state) { attackSamples.count { !it.cancelled }.shouldBeExactly(1) } } finally { HandlerList.unregisterAll(listener) runSync { fakeAttacker?.removePlayer() victim?.remove() } } } test("fire aspect afterburn matches environmental fire tick damage (zombie)") { lateinit var attacker: Player lateinit var victim: LivingEntity var fakeAttacker: FakePlayer? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(victim) } val environmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } val afterburn = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) attackCompat(attacker, victim) ensureBurning(victim, minTicks = 200) } delayTicks(12) } val environmentalAvg = environmental.average() val afterburnAvg = afterburn.average() abs(afterburnAvg - environmentalAvg).shouldBeLessThan(0.25) } finally { runSync { fakeAttacker?.removePlayer() victim.remove() } } } test("fire aspect afterburn matches environmental fire tick damage (player)") { if (isLegacyServer) return@test lateinit var attacker: Player lateinit var victim: Player var fakeAttacker: FakePlayer? = null var fakeVictim: FakePlayer? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA val (fakeV, playerV) = spawnPlayer(victimLocation) fakeVictim = fakeV victim = playerV prepareVictimState(victim) } val environmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } val afterburn = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) attackCompat(attacker, victim) ensureBurning(victim, minTicks = 200) } delayTicks(12) } val environmentalAvg = environmental.average() val afterburnAvg = afterburn.average() abs(afterburnAvg - environmentalAvg).shouldBeLessThan(0.25) } finally { runSync { fakeAttacker?.removePlayer() fakeVictim?.removePlayer() } } } test("fire aspect afterburn matches environmental fire tick damage with protection armour (zombie)") { // Use an armoured mob victim to keep fire tick sampling stable across versions. lateinit var attacker: Player lateinit var victim: LivingEntity var fakeAttacker: FakePlayer? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(victim) applyProtectionArmour(victim) } val environmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } val afterburn = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) attackCompat(attacker, victim) victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } delayTicks(12) } val environmentalAvg = environmental.average() val afterburnAvg = afterburn.average() abs(afterburnAvg - environmentalAvg).shouldBeLessThan(0.25) } finally { runSync { fakeAttacker?.removePlayer() victim.remove() } } } test("fire aspect afterburn matches environmental fire tick damage with protection armour (player)") { if (isLegacyServer) return@test lateinit var attacker: Player lateinit var victim: Player var fakeAttacker: FakePlayer? = null var fakeVictim: FakePlayer? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA val (fakeV, playerV) = spawnPlayer(victimLocation) fakeVictim = fakeV victim = playerV prepareVictimState(victim) applyProtectionArmour(victim) } val environmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } val afterburn = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) attackCompat(attacker, victim) ensureBurning(victim, minTicks = 200) } delayTicks(12) } val environmentalAvg = environmental.average() val afterburnAvg = afterburn.average() abs(afterburnAvg - environmentalAvg).shouldBeLessThan(0.25) } finally { runSync { fakeAttacker?.removePlayer() fakeVictim?.removePlayer() } } } test("fire aspect does not increase successful hits during rapid clicking") { lateinit var attacker: Player lateinit var victim: LivingEntity var fakeAttacker: FakePlayer? = null var fireTickCount = 0 val fireTickSamples = mutableListOf() val fireTickListener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onFireTick(event: EntityDamageEvent) { if (event.entity.uniqueId != victim.uniqueId) return val cause = event.cause if (cause == EntityDamageEvent.DamageCause.FIRE || cause == EntityDamageEvent.DamageCause.FIRE_TICK ) { fireTickCount++ fireTickSamples.add(FireTickSample(event.isCancelled, event.finalDamage)) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(victim, maxHealthOverride = 200.0) } val baselineWeapon = ItemStack(Material.DIAMOND_SWORD) val fireWeapon = ItemStack(Material.DIAMOND_SWORD).also { item -> val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { item.addUnsafeEnchantment(fireAspect, 2) } } Bukkit.getPluginManager().registerEvents(fireTickListener, plugin) runSync { prepareVictimState(victim, maxHealthOverride = 200.0) } val baselineHits = countSuccessfulAttacks(attacker, victim, baselineWeapon, attempts = 30, tickDelay = 1) runSync { prepareVictimState(victim, maxHealthOverride = 200.0) } val fireHits = countSuccessfulAttacks(attacker, victim, fireWeapon, attempts = 5, tickDelay = 1).also { runSync { ensureBurning(victim, minTicks = 200) } } waitForFireTick(fireTickSamples) val remainingHits = countSuccessfulAttacks(attacker, victim, fireWeapon, attempts = 25, tickDelay = 1) val totalFireHits = fireHits + remainingHits fireTickCount.shouldBeGreaterThan(0) abs(totalFireHits - baselineHits).shouldBeLessThanOrEqual(2) } finally { HandlerList.unregisterAll(fireTickListener) runSync { fakeAttacker?.removePlayer() victim.remove() } } } test("fire aspect does not increase successful hits for fire resistant or fire immune victims") { lateinit var attacker: Player var fakeAttacker: FakePlayer? = null var fakeVictim: FakePlayer? = null var blaze: LivingEntity? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA val (fakeV, playerV) = spawnPlayer(victimLocation) fakeVictim = fakeV prepareVictimState(playerV, maxHealthOverride = 200.0) applyFireResistance(playerV) } val baselineWeapon = ItemStack(Material.DIAMOND_SWORD) val fireWeapon = ItemStack(Material.DIAMOND_SWORD).also { item -> val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) item.addUnsafeEnchantment(fireAspect, 2) } val fireResBaseline = countSuccessfulAttacks( attacker = attacker, victim = checkNotNull(Bukkit.getPlayer(checkNotNull(fakeVictim).uuid)), weapon = baselineWeapon, attempts = 30, tickDelay = 1 ) runSync { val victim = checkNotNull(Bukkit.getPlayer(checkNotNull(fakeVictim).uuid)) prepareVictimState(victim, maxHealthOverride = 200.0) applyFireResistance(victim) } val fireResWithFireAspect = countSuccessfulAttacks( attacker = attacker, victim = checkNotNull(Bukkit.getPlayer(checkNotNull(fakeVictim).uuid)), weapon = fireWeapon, attempts = 30, tickDelay = 1 ) abs(fireResWithFireAspect - fireResBaseline).shouldBeLessThanOrEqual(2) runSync { val world = checkNotNull(Bukkit.getWorld("world")) val blazeLocation = Location(world, 1.2, 100.0, 2.0) blaze = world.spawn(blazeLocation, org.bukkit.entity.Blaze::class.java).apply { maximumNoDamageTicks = 100 noDamageTicks = 0 isInvulnerable = false health = maxHealth } disableAiIfPossible(checkNotNull(blaze)) stabilise(checkNotNull(blaze), blazeLocation) } val blazeBaseline = countSuccessfulAttacks( attacker = attacker, victim = checkNotNull(blaze), weapon = baselineWeapon, attempts = 30, tickDelay = 1 ) runSync { prepareVictimState(checkNotNull(blaze), maxHealthOverride = 200.0) stabilise(checkNotNull(blaze), checkNotNull(blaze).location) } val blazeWithFireAspect = countSuccessfulAttacks( attacker = attacker, victim = checkNotNull(blaze), weapon = fireWeapon, attempts = 30, tickDelay = 1 ) abs(blazeWithFireAspect - blazeBaseline).shouldBeLessThanOrEqual(2) } finally { runSync { fakeAttacker?.removePlayer() fakeVictim?.removePlayer() blaze?.remove() } } } test("fire protection reduces fire tick damage and afterburn matches environmental") { lateinit var attacker: Player lateinit var victim: LivingEntity var fakeAttacker: FakePlayer? = null try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnPlayer(attackerLocation) fakeAttacker = fakeA attacker = playerA victim = spawnVictim(victimLocation) prepareVictimState(victim) } runSync { applyProtectionArmour(victim) } val protEnvironmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } runSync { prepareVictimState(victim) applyFireProtectionArmour(victim) } val fireProtEnvironmental = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 ensureBurning(victim, minTicks = 200) } } val tolerance = if (Reflector.versionIsNewerOrEqualTo(1, 20, 0)) 0.35 else 0.5 fireProtEnvironmental.average().shouldBeLessThan(protEnvironmental.average() + tolerance + 1e-6) runSync { prepareVictimState(victim) applyFireProtectionArmour(victim) } val afterburn = collectFireTickDamages(victim, 1) { runSync { victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 victim.lastDamage = 0.0 val weapon = ItemStack(Material.DIAMOND_SWORD) val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) { weapon.addUnsafeEnchantment(fireAspect, 2) } equip(attacker, weapon) attackCompat(attacker, victim) ensureBurning(victim, minTicks = 200) } delayTicks(12) } abs(afterburn.average() - fireProtEnvironmental.average()).shouldBeLessThan(tolerance) } finally { runSync { fakeAttacker?.removePlayer() victim.remove() } } } test("water extinguishes fire without fire tick damage") { lateinit var victim: Player var fakeVictim: FakePlayer? = null var blockSnapshots: List = emptyList() val samples = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onFireTick(event: EntityDamageEvent) { if (event.entity.uniqueId != victim.uniqueId) return val cause = event.cause if (cause != EntityDamageEvent.DamageCause.FIRE_TICK && cause != EntityDamageEvent.DamageCause.FIRE ) return samples.add(FireTickSample(event.isCancelled, event.finalDamage)) } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val victimLocation = Location(world, 0.5, 100.0, 0.5) val (fakeV, playerV) = spawnPlayer(victimLocation) fakeVictim = fakeV victim = playerV prepareVictimState(victim) blockSnapshots = placeWaterColumn(world, victimLocation, height = 2) stabilise(victim, victimLocation) Bukkit.getPluginManager().registerEvents(listener, plugin) ensureBurning(victim, minTicks = 200) } // Allow the initial tick or two to settle (some versions may still emit an early fire damage event). delayTicks(2) runSync { samples.clear() } delayTicks(20) val hadPositiveDamage = samples.any { !it.cancelled && it.finalDamage > 0.0 } hadPositiveDamage.shouldBe(false) runSync { victim.fireTicks.shouldBeLessThanOrEqual(1) } } finally { HandlerList.unregisterAll(listener) runSync { restoreBlocks(blockSnapshots) fakeVictim?.removePlayer() } } } test("fire tick does not let a second attacker bypass invulnerability") { lateinit var attackerA: Player lateinit var attackerB: Player lateinit var victim: LivingEntity var fakeA: FakePlayer? = null var fakeB: FakePlayer? = null val samples = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onDamage(event: EntityDamageByEntityEvent) { if (event.entity.uniqueId != victim.uniqueId) return if (event.cause != EntityDamageEvent.DamageCause.ENTITY_ATTACK) return if (event.damager.uniqueId != attackerA.uniqueId && event.damager.uniqueId != attackerB.uniqueId ) return samples.add( AttackSample( cancelled = event.isCancelled, damage = event.damage, finalDamage = event.finalDamage, noDamageTicks = victim.noDamageTicks, lastDamage = victim.lastDamage ) ) } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val aLocation = Location(world, 0.0, 100.0, 0.0) val bLocation = Location(world, 0.0, 100.0, 2.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fa, pa) = spawnPlayer(aLocation) fakeA = fa attackerA = pa val (fb, pb) = spawnPlayer(bLocation) fakeB = fb attackerB = pb victim = spawnVictim(victimLocation) prepareVictimState(victim) val fireWeapon = ItemStack(Material.DIAMOND_SWORD).also { item -> val fireAspect = XEnchantment.FIRE_ASPECT.get() if (fireAspect != null) item.addUnsafeEnchantment(fireAspect, 2) } equip(attackerA, fireWeapon) equip(attackerB, ItemStack(Material.DIAMOND_SWORD)) Bukkit.getPluginManager().registerEvents(listener, plugin) } if (needsAttackWarmup(attackerA)) { delayTicks(6) } runSync { attackCompat(attackerA, victim) } delayTicks(2) runSync { val fireEvent = EntityDamageEvent(victim, EntityDamageEvent.DamageCause.FIRE_TICK, 1.0) Bukkit.getPluginManager().callEvent(fireEvent) } runSync { requireInvulnerabilityWindow(victim) } if (needsAttackWarmup(attackerB)) { delayTicks(6) } runSync { attackCompat(attackerB, victim) } delayTicks(2) samples.count { !it.cancelled }.shouldBeExactly(1) } finally { HandlerList.unregisterAll(listener) runSync { fakeA?.removePlayer() fakeB?.removePlayer() victim.remove() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/FishingRodVelocityIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeLessThan import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleFishingRodVelocity import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Entity import org.bukkit.entity.FishHook import org.bukkit.entity.Player import org.bukkit.event.player.PlayerFishEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.util.Vector import java.util.Random import java.util.UUID import java.util.concurrent.Callable import java.lang.reflect.InvocationHandler import java.lang.reflect.Proxy import kotlin.math.cos import kotlin.math.abs import kotlin.math.sin import kotlin.math.sqrt @OptIn(ExperimentalKotest::class) class FishingRodVelocityIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleFishingRodVelocity not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } fun setModeset(player: Player, modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) } fun setModuleRandomSeed(seed: Long) { val field = module.javaClass.getDeclaredField("random") field.isAccessible = true field.set(module, Random(seed)) } fun assertVectorClose(actual: Vector, expected: Vector, tolerance: Double) { abs(actual.x - expected.x) shouldBeLessThan tolerance abs(actual.y - expected.y) shouldBeLessThan tolerance abs(actual.z - expected.z) shouldBeLessThan tolerance } fun createFishEvent(player: Player, hook: FishHook, state: PlayerFishEvent.State): PlayerFishEvent { val ctors = PlayerFishEvent::class.java.constructors for (ctor in ctors) { val paramTypes = ctor.parameterTypes val hasFishHookParam = paramTypes.any { FishHook::class.java.isAssignableFrom(it) } val args = arrayOfNulls(paramTypes.size) var ok = true var hookAssigned = false for (i in paramTypes.indices) { val t = paramTypes[i] args[i] = when { Player::class.java.isAssignableFrom(t) -> player FishHook::class.java.isAssignableFrom(t) -> { hookAssigned = true hook } Entity::class.java.isAssignableFrom(t) -> { if (hasFishHookParam) { // Treat as "caught" entity slot in modern signatures null } else if (!hookAssigned) { // Legacy signatures sometimes use Entity for the hook hookAssigned = true hook } else { null } } PlayerFishEvent.State::class.java.isAssignableFrom(t) -> state t == Int::class.javaPrimitiveType -> 0 t == Boolean::class.javaPrimitiveType -> false t.isEnum && t.name.endsWith("EquipmentSlot") -> { // Prefer main-hand if present (modern signature) runCatching { java.lang.Enum.valueOf(t as Class>, "HAND") }.getOrNull() } ItemStack::class.java.isAssignableFrom(t) -> ItemStack(Material.FISHING_ROD) else -> null } // If we failed to provide a value for a primitive, this ctor won't work if (args[i] == null && t.isPrimitive) { ok = false break } } if (!ok) continue try { @Suppress("UNCHECKED_CAST") val event = ctor.newInstance(*args) as PlayerFishEvent // Validate that the event reports the expected hook; legacy signatures vary. val hookObj = runCatching { PlayerFishEvent::class.java.getMethod("getHook").invoke(event) }.getOrNull() val hookFromEvent = hookObj as? FishHook ?: continue if (hookFromEvent.uniqueId != hook.uniqueId) continue return event } catch (_: Throwable) { // Try next } } error("No compatible PlayerFishEvent constructor found for this server version") } fun createFakeHook(player: Player): FishHook { val id = UUID.randomUUID() var velocity = Vector(0.0, 0.0, 0.0) val handler = InvocationHandler { _, method, args -> when (method.name) { "getUniqueId" -> return@InvocationHandler id "getVelocity" -> return@InvocationHandler velocity "setVelocity" -> { velocity = (args?.get(0) as? Vector) ?: velocity return@InvocationHandler null } "isValid" -> return@InvocationHandler true "remove" -> return@InvocationHandler null "getWorld" -> return@InvocationHandler player.world "getLocation" -> return@InvocationHandler player.location.clone() } return@InvocationHandler when (method.returnType) { java.lang.Boolean.TYPE -> false java.lang.Integer.TYPE -> 0 java.lang.Long.TYPE -> 0L java.lang.Float.TYPE -> 0f java.lang.Double.TYPE -> 0.0 java.lang.Void.TYPE -> null else -> null } } val interfaces = mutableListOf>(FishHook::class.java) runCatching { Class.forName("org.bukkit.entity.Fish") } .getOrNull() ?.takeIf { it.isInterface } ?.let { interfaces.add(it) } return Proxy.newProxyInstance( FishHook::class.java.classLoader, interfaces.toTypedArray(), handler ) as FishHook } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getWorld("world") ?: error("world not loaded") val location = Location(world, 0.0, 120.0, 0.0, 45f, 10f) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = Bukkit.getPlayer(fakePlayer.uuid) ?: error("Player not found") setModeset(player, "old") module.reload() } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { setModeset(player, "old") module.reload() player.inventory.setItemInMainHand(ItemStack(Material.FISHING_ROD)) } } test("sets hook velocity to the 1.8 formula (deterministic random seed)") { val hook = if (Reflector.versionIsNewerOrEqualTo(1, 14, 0)) { runSync { player.launchProjectile(FishHook::class.java) } } else { createFakeHook(player) } try { runSync { // Keep everything in a single main-thread slice so hook physics cannot tick between steps (legacy servers are sensitive). setModuleRandomSeed(0) val event = createFishEvent(player, hook, PlayerFishEvent.State.FISHING) module.onFishEvent(event) // Mirror the module's float-heavy computation so Java 8/legacy servers match precisely. val yaw = player.location.yaw.toDouble() val pitch = player.location.pitch.toDouble() val oldMaxVelocity = 0.4f.toDouble() val piF = Math.PI.toFloat().toDouble() val degF = 180.0f.toDouble() var vx = -sin(yaw / degF * piF) * cos(pitch / degF * piF) * oldMaxVelocity var vz = cos(yaw / degF * piF) * cos(pitch / degF * piF) * oldMaxVelocity var vy = -sin(pitch / degF * piF) * oldMaxVelocity val oldVelocityMultiplier = 1.5 val vectorLength = sqrt(vx * vx + vy * vy + vz * vz).toFloat().toDouble() vx /= vectorLength vy /= vectorLength vz /= vectorLength val rng = Random(0) vx += rng.nextGaussian() * 0.007499999832361937 vy += rng.nextGaussian() * 0.007499999832361937 vz += rng.nextGaussian() * 0.007499999832361937 vx *= oldVelocityMultiplier vy *= oldVelocityMultiplier vz *= oldVelocityMultiplier val expected = Vector(vx, vy, vz) val actual = hook.velocity assertVectorClose(actual, expected, 1e-6) } } finally { if (Reflector.versionIsNewerOrEqualTo(1, 14, 0)) { runSync { hook.remove() } } } } test("does not modify hook velocity for non-FISHING states") { val hook = if (Reflector.versionIsNewerOrEqualTo(1, 14, 0)) { runSync { player.launchProjectile(FishHook::class.java) } } else { createFakeHook(player) } try { val nonFishing = PlayerFishEvent.State.values().firstOrNull { it != PlayerFishEvent.State.FISHING } ?: error("No non-FISHING PlayerFishEvent state available") runSync { val original = Vector(0.123, 0.456, -0.789) hook.velocity = original val baseline = hook.velocity val event = createFishEvent(player, hook, nonFishing) module.onFishEvent(event) val actual = hook.velocity assertVectorClose(actual, baseline, 1e-8) } } finally { if (Reflector.versionIsNewerOrEqualTo(1, 14, 0)) { runSync { hook.remove() } } } } test("1.14+ applies an extra gravity tick when the hook is not in water") { if (!Reflector.versionIsNewerOrEqualTo(1, 14, 0)) return@test val hookBaseline = runSync { player.launchProjectile(FishHook::class.java) } val hookWithModule = runSync { player.launchProjectile(FishHook::class.java) } try { runSync { // Keep both hooks colocated so vanilla physics is as close as possible hookWithModule.teleport(hookBaseline.location) // Schedule the module's per-tick gravity adjustment for hookWithModule val event = createFishEvent(player, hookWithModule, PlayerFishEvent.State.FISHING) Bukkit.getPluginManager().callEvent(event) // Force the same starting velocity for both so we can compare deltas val start = Vector(0.0, 0.2, 0.0) hookBaseline.velocity = start hookWithModule.velocity = start } // Wait for at least one tick of the module's gravity adjustment delay(3 * 50L) val yBaseline = runSync { hookBaseline.velocity.y } val yWithModule = runSync { hookWithModule.velocity.y } // Module subtracts an extra 0.01 from Y each tick (when not in water), // so it should be noticeably more negative than the baseline hook. (yWithModule < yBaseline - 0.005) shouldBe true } finally { runSync { hookBaseline.remove() hookWithModule.remove() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/GoldenAppleIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XMaterial import com.cryptomorin.xseries.XPotion import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.ints.shouldBeGreaterThanOrEqual import io.kotest.matchers.ints.shouldBeLessThanOrEqual import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe import io.kotest.matchers.longs.shouldBeBetween import kernitus.plugin.OldCombatMechanics.module.ModuleGoldenApple import kotlinx.coroutines.delay import kotlinx.coroutines.suspendCancellableCoroutine import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.Attribute import org.bukkit.entity.Player import org.bukkit.event.inventory.PrepareItemCraftEvent import org.bukkit.event.player.PlayerItemConsumeEvent import org.bukkit.inventory.CraftingInventory import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.potion.PotionEffect import org.bukkit.potion.PotionEffectType import kotlin.coroutines.resume import kernitus.plugin.OldCombatMechanics.TesterUtils.getPotionEffectCompat @OptIn(ExperimentalKotest::class) class GoldenAppleIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleGoldenApple.getInstance() lateinit var player: Player lateinit var fakePlayer: FakePlayer suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val oldPotionEffects = ocm.config.getBoolean("old-golden-apples.old-potion-effects") val normalCooldown = ocm.config.getLong("old-golden-apples.cooldown.normal") val enchantedCooldown = ocm.config.getLong("old-golden-apples.cooldown.enchanted") val sharedCooldown = ocm.config.getBoolean("old-golden-apples.cooldown.is-shared") val crafting = ocm.config.getBoolean("old-golden-apples.enchanted-golden-apple-crafting") val noConflict = ocm.config.getBoolean("old-golden-apples.no-conflict-mode") try { block() } finally { ocm.config.set("old-golden-apples.old-potion-effects", oldPotionEffects) ocm.config.set("old-golden-apples.cooldown.normal", normalCooldown) ocm.config.set("old-golden-apples.cooldown.enchanted", enchantedCooldown) ocm.config.set("old-golden-apples.cooldown.is-shared", sharedCooldown) ocm.config.set("old-golden-apples.enchanted-golden-apple-crafting", crafting) ocm.config.set("old-golden-apples.no-conflict-mode", noConflict) module.reload() ModuleLoader.toggleModules() } } extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin) { action() null }.get() } } fun setModeset(modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) } fun callConsume(item: ItemStack): PlayerItemConsumeEvent { val ctor = PlayerItemConsumeEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 3 && Player::class.java.isAssignableFrom(params[0]) && ItemStack::class.java.isAssignableFrom(params[1]) && EquipmentSlot::class.java.isAssignableFrom(params[2]) } val event = if (ctor != null) { ctor.newInstance(player, item, EquipmentSlot.HAND) as PlayerItemConsumeEvent } else { PlayerItemConsumeEvent(player, item) } Bukkit.getPluginManager().callEvent(event) return event } fun prepareCraftResult(result: ItemStack): PrepareItemCraftEvent { val openWorkbench = player.javaClass.getMethod( "openWorkbench", Location::class.java, Boolean::class.javaPrimitiveType ) val viewObj = openWorkbench.invoke(player, null, true) ?: error("Workbench view was null") val getTopInventory = viewObj.javaClass.getMethod("getTopInventory") val inventory = getTopInventory.invoke(viewObj) as CraftingInventory inventory.result = result val ctor = PrepareItemCraftEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 3 && CraftingInventory::class.java.isAssignableFrom(params[0]) && params[2] == Boolean::class.javaPrimitiveType } ?: error("PrepareItemCraftEvent constructor not found") return ctor.newInstance(inventory, viewObj, false) as PrepareItemCraftEvent } fun assertDuration(effect: PotionEffect?, expectedTicks: Int) { effect.shouldNotBe(null) val duration = effect!!.duration duration.shouldBeGreaterThanOrEqual(expectedTicks - 10) duration.shouldBeLessThanOrEqual(expectedTicks) } suspend fun waitForEffects(ticks: Long = 2L) { suspendCancellableCoroutine { continuation -> Bukkit.getScheduler().runTaskLater(testPlugin, Runnable { if (continuation.isActive) { continuation.resume(Unit) } }, ticks) } } fun maxHealthAttribute(): Attribute { return XAttribute.MAX_HEALTH.get() ?: error("Max health attribute not available") } fun enchantedAppleItem(): ItemStack { return XMaterial.ENCHANTED_GOLDEN_APPLE.parseItem() ?: error("Enchanted golden apple item not available") } beforeSpec { runSync { val world = Bukkit.getServer().getWorld("world") val location = Location(world, 0.0, 100.0, 0.0) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) player.gameMode = GameMode.SURVIVAL player.maximumNoDamageTicks = 20 player.noDamageTicks = 0 player.isInvulnerable = false player.isOp = true setModeset("old") } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.health = player.getAttribute(maxHealthAttribute())!!.value player.foodLevel = 20 setModeset("old") module.reload() } } context("Potion Effects") { test("golden apple applies configured effects") { player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) waitForEffects() val regeneration = player.getPotionEffectCompat(PotionEffectType.REGENERATION) val absorption = player.getPotionEffectCompat(PotionEffectType.ABSORPTION) assertDuration(regeneration, 5 * 20) regeneration?.amplifier shouldBe 1 assertDuration(absorption, 120 * 20) absorption?.amplifier shouldBe 0 } test("enchanted golden apple applies configured effects") { player.inventory.setItemInMainHand(enchantedAppleItem()) callConsume(player.inventory.itemInMainHand) waitForEffects() val regeneration = player.getPotionEffectCompat(PotionEffectType.REGENERATION) val absorption = player.getPotionEffectCompat(PotionEffectType.ABSORPTION) val resistance = player.getPotionEffectCompat(XPotion.RESISTANCE.get()!!) val fireResistance = player.getPotionEffectCompat(PotionEffectType.FIRE_RESISTANCE) assertDuration(regeneration, 30 * 20) regeneration?.amplifier shouldBe 4 assertDuration(absorption, 120 * 20) absorption?.amplifier shouldBe 0 assertDuration(resistance, 300 * 20) resistance?.amplifier shouldBe 0 assertDuration(fireResistance, 300 * 20) fireResistance?.amplifier shouldBe 0 } test("higher amplifier replaces existing effect") { player.addPotionEffect(PotionEffect(PotionEffectType.REGENERATION, 100, 0)) player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) waitForEffects() val regeneration = player.getPotionEffectCompat(PotionEffectType.REGENERATION) regeneration?.amplifier shouldBe 1 assertDuration(regeneration, 5 * 20) } test("same amplifier with longer duration refreshes effect") { player.addPotionEffect(PotionEffect(PotionEffectType.REGENERATION, 50, 1)) player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) waitForEffects() val regeneration = player.getPotionEffectCompat(PotionEffectType.REGENERATION) regeneration?.amplifier shouldBe 1 assertDuration(regeneration, 5 * 20) } test("lower amplifier does not override existing effect") { player.addPotionEffect(PotionEffect(PotionEffectType.REGENERATION, 100, 3)) player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) waitForEffects() val regeneration = player.getPotionEffectCompat(PotionEffectType.REGENERATION) regeneration?.amplifier shouldBe 3 } test("old-potion-effects disabled leaves effects unchanged") { withConfig { ocm.config.set("old-golden-apples.old-potion-effects", false) module.reload() player.addPotionEffect(PotionEffect(PotionEffectType.SPEED, 200, 0)) player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) waitForEffects() player.getPotionEffectCompat(PotionEffectType.SPEED).shouldNotBe(null) player.getPotionEffectCompat(PotionEffectType.REGENERATION).shouldBe(null) player.getPotionEffectCompat(PotionEffectType.ABSORPTION).shouldBe(null) } } } context("Cooldowns") { test("repeated consumption is blocked by cooldown") { withConfig { ocm.config.set("old-golden-apples.cooldown.normal", 60) ocm.config.set("old-golden-apples.cooldown.enchanted", 0) ocm.config.set("old-golden-apples.cooldown.is-shared", false) module.reload() player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) val first = callConsume(player.inventory.itemInMainHand) first.isCancelled shouldBe false val second = callConsume(player.inventory.itemInMainHand) second.isCancelled shouldBe true } } test("shared cooldown blocks other apple type") { withConfig { ocm.config.set("old-golden-apples.cooldown.normal", 60) ocm.config.set("old-golden-apples.cooldown.enchanted", 60) ocm.config.set("old-golden-apples.cooldown.is-shared", true) module.reload() player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) player.inventory.setItemInMainHand(enchantedAppleItem()) val enchantedEvent = callConsume(player.inventory.itemInMainHand) enchantedEvent.isCancelled shouldBe true } } test("separate cooldown allows other apple type") { withConfig { ocm.config.set("old-golden-apples.cooldown.normal", 60) ocm.config.set("old-golden-apples.cooldown.enchanted", 60) ocm.config.set("old-golden-apples.cooldown.is-shared", false) module.reload() player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) player.inventory.setItemInMainHand(enchantedAppleItem()) val enchantedEvent = callConsume(player.inventory.itemInMainHand) enchantedEvent.isCancelled shouldBe false } } test("cooldown getters return remaining seconds") { withConfig { ocm.config.set("old-golden-apples.cooldown.normal", 5) ocm.config.set("old-golden-apples.cooldown.enchanted", 5) ocm.config.set("old-golden-apples.cooldown.is-shared", false) module.reload() player.inventory.setItemInMainHand(ItemStack(Material.GOLDEN_APPLE)) callConsume(player.inventory.itemInMainHand) module.getGappleCooldown(player.uniqueId).shouldBeBetween(1, 5) player.inventory.setItemInMainHand(enchantedAppleItem()) callConsume(player.inventory.itemInMainHand) module.getNappleCooldown(player.uniqueId).shouldBeBetween(1, 5) } } } context("Crafting") { test("enchanted golden apple crafting is blocked when disabled") { withConfig { ocm.config.set("old-golden-apples.enchanted-golden-apple-crafting", false) ocm.config.set("old-golden-apples.no-conflict-mode", false) module.reload() val event = prepareCraftResult(enchantedAppleItem()) Bukkit.getPluginManager().callEvent(event) event.inventory.result.shouldBe(null) player.closeInventory() } } test("no-conflict-mode preserves crafting result") { withConfig { ocm.config.set("old-golden-apples.enchanted-golden-apple-crafting", false) ocm.config.set("old-golden-apples.no-conflict-mode", true) module.reload() val event = prepareCraftResult(enchantedAppleItem()) Bukkit.getPluginManager().callEvent(event) event.inventory.result.shouldNotBe(null) player.closeInventory() } } test("unknown modeset disables crafting") { withConfig { ocm.config.set("old-golden-apples.enchanted-golden-apple-crafting", true) ocm.config.set("old-golden-apples.no-conflict-mode", false) module.reload() setModeset("missing") val event = prepareCraftResult(enchantedAppleItem()) Bukkit.getPluginManager().callEvent(event) event.inventory.result.shouldBe(null) player.closeInventory() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/InGameTester.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XEnchantment import com.cryptomorin.xseries.XPotion import kernitus.plugin.OldCombatMechanics.TesterUtils.assertEquals import kernitus.plugin.OldCombatMechanics.utilities.damage.DamageUtils.getOldSharpnessDamage import kernitus.plugin.OldCombatMechanics.utilities.damage.DamageUtils.isCriticalHit1_8 import kernitus.plugin.OldCombatMechanics.utilities.damage.DefenceUtils.getDamageAfterArmour1_8 import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages.getDamage import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kernitus.plugin.OldCombatMechanics.TesterUtils.getPotionEffectCompat import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.AttributeModifier import org.bukkit.command.CommandSender import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.potion.PotionEffect import java.util.* import java.util.function.Consumer import kotlin.math.max class InGameTester(private val plugin: JavaPlugin) { private var tally: Tally? = null private var sender: CommandSender? = null private lateinit var attacker: Player private lateinit var defender: Player private lateinit var fakeAttacker: FakePlayer private lateinit var fakeDefender: FakePlayer private val testQueue: Queue = ArrayDeque() /** * Perform all tests using the two specified players */ fun performTests(sender: CommandSender?, location: Location) { plugin.logger.info("PERFORMING THE TESTS") this.sender = sender fakeAttacker = FakePlayer(plugin) plugin.logger.info("FAKE") fakeAttacker.spawn(location.add(2.0, 0.0, 0.0)) plugin.logger.info("FAKE2") fakeDefender = FakePlayer(plugin) val defenderLocation = location.add(0.0, 0.0, 2.0) fakeDefender.spawn(defenderLocation) attacker = checkNotNull(Bukkit.getPlayer(fakeAttacker.uuid)) defender = checkNotNull(Bukkit.getPlayer(fakeDefender.uuid)) // Turn defender to face attacker defenderLocation.yaw = 180f defenderLocation.pitch = 0f defender.teleport(defenderLocation) // modeset of attacker takes precedence var playerData = getPlayerData(attacker.uniqueId) playerData.setModesetForWorld(attacker.world.uid, "old") setPlayerData(attacker.uniqueId, playerData) playerData = getPlayerData(defender.uniqueId) playerData.setModesetForWorld(defender.world.uid, "new") setPlayerData(defender.uniqueId, playerData) beforeAll() tally = Tally() // Queue all tests //runAttacks(new ItemStack[]{}, () -> {}); // with no armour testArmour() //testEnchantedMelee(new ItemStack[]{}, () -> {}); // Run all tests in the queue runQueuedTests() } private fun runAttacks(armour: Array, preparations: Runnable) { //testMelee(armour, preparations); testEnchantedMelee(armour, preparations) testOverdamage(armour, preparations) } private fun testArmour() { val materials = arrayOf("LEATHER", "CHAINMAIL", "GOLDEN", "IRON", "DIAMOND", "NETHERITE") val slots = arrayOf("BOOTS", "LEGGINGS", "CHESTPLATE", "HELMET") val random = Random(System.currentTimeMillis()) val armourContents = Array(4) { i -> val slot = slots[i] // Pick a random material for each slot val material = materials[random.nextInt(materials.size)] val itemStack = ItemStack(Material.valueOf("${material}_$slot")) // Apply enchantment to the armour piece itemStack.addUnsafeEnchantment(XEnchantment.PROTECTION.get()!!, 50) itemStack } runAttacks(armourContents) { defender.inventory.setArmorContents(armourContents) // Test status effects on defence: resistance, fire resistance, absorption defender.addPotionEffect(PotionEffect(XPotion.RESISTANCE.potionEffectType!!, 10, 1)) fakeDefender.doBlocking() } } private fun testEnchantedMelee(armour: Array, preparations: Runnable) { for (weaponType in kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages.getMaterialDamages().keys) { val weapon = ItemStack(weaponType) // only axe and sword can have sharpness try { weapon.addEnchantment(XEnchantment.SHARPNESS.get()!!, 3) } catch (ignored: IllegalArgumentException) { } val message = weaponType.name + " Sharpness 3" queueAttack(OCMTest(weapon, armour, 2, message) { preparations.run() defender.maximumNoDamageTicks = 0 attacker.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 10, 0, false)) attacker.addPotionEffect(PotionEffect(XPotion.WEAKNESS.get()!!, 10, -1, false)) plugin.logger.info("TESTING WEAPON $weaponType") attacker.fallDistance = 2f // Crit }) } } private fun testMelee(armour: Array, preparations: Runnable) { for (weaponType in kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages.getMaterialDamages().keys) { val weapon = ItemStack(weaponType) queueAttack(OCMTest(weapon, armour, 1, weaponType.name) { preparations.run() defender.maximumNoDamageTicks = 0 }) } } private fun testOverdamage(armour: Array, preparations: Runnable) { // 1, 5, 6, 7, 3, 8 according to OCM // 1, 4, 5, 6, 2, 7 according to 1.9+ val weapons = arrayOf( Material.WOODEN_HOE, Material.WOODEN_SWORD, Material.STONE_SWORD, Material.IRON_SWORD, Material.WOODEN_PICKAXE, Material.DIAMOND_SWORD ) for (weaponType in weapons) { val weapon = ItemStack(weaponType) queueAttack(OCMTest(weapon, armour, 3, weaponType.name, Runnable { preparations.run() defender.maximumNoDamageTicks = 30 })) } } private fun queueAttack(test: OCMTest) { testQueue.add(test) } private fun calculateAttackDamage(weapon: ItemStack): Double { val weaponType = weapon.type // Attack components order: (Base + Potion effects, scaled by attack delay) + Critical Hit + (Enchantments, scaled by attack delay) // Hurt components order: Overdamage - Armour Effects var expectedDamage = getDamage(weaponType) // Weakness effect, 1.8: -0.5 // We ignore the level as there is only one level of weakness potion val weaknessAddend = if (attacker.hasPotionEffect(XPotion.WEAKNESS.get()!!)) -0.5 else 0.0 // Strength effect // 1.8: +130% for each strength level val strength = attacker.getPotionEffectCompat(XPotion.STRENGTH.get()!!) if (strength != null) expectedDamage += (strength.amplifier + 1) * 1.3 * expectedDamage expectedDamage += weaknessAddend // Take into account damage reduction because of cooldown val attackCooldown = defender.attackCooldown expectedDamage *= (0.2f + attackCooldown * attackCooldown * 0.8f).toDouble() // Critical hit if (isCriticalHit1_8(attacker)) { expectedDamage *= 1.5 } // Weapon Enchantments var sharpnessDamage = getOldSharpnessDamage(weapon.getEnchantmentLevel(XEnchantment.SHARPNESS.get()!!)) sharpnessDamage *= attackCooldown.toDouble() // Scale by attack cooldown strength expectedDamage += sharpnessDamage return expectedDamage } private fun wasFakeOverdamage(weapon: ItemStack): Boolean { val weaponDamage = calculateAttackDamage(weapon) val lastDamage = defender.lastDamage return defender.noDamageTicks.toFloat() > defender.maximumNoDamageTicks.toFloat() / 2.0f && weaponDamage <= lastDamage } private fun wasOverdamaged(rawWeaponDamage: Double): Boolean { val lastDamage = defender.lastDamage return defender.noDamageTicks.toFloat() > defender.maximumNoDamageTicks.toFloat() / 2.0f && rawWeaponDamage > lastDamage } private fun calculateExpectedDamage(weapon: ItemStack, armourContents: Array): Float { var expectedDamage = calculateAttackDamage(weapon) if (wasOverdamaged(expectedDamage)) { val lastDamage = defender.lastDamage plugin.logger.info("Overdamaged: " + expectedDamage + " - " + lastDamage + " = " + (expectedDamage - lastDamage)) expectedDamage -= lastDamage } if (defender.isBlocking) { plugin.logger.info("DEFENDER IS BLOCKING $expectedDamage") expectedDamage -= max(0.0, (expectedDamage - 1)) * 0.5 plugin.logger.info("AFTER BLOCK $expectedDamage") } expectedDamage = getDamageAfterArmour1_8( defender, expectedDamage, armourContents, EntityDamageEvent.DamageCause.ENTITY_ATTACK, false ) return expectedDamage.toFloat() } private fun runQueuedTests() { plugin.logger.info("Running " + testQueue.size + " tests") val listener: Listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR) fun onEvent(e: EntityDamageByEntityEvent) { val damager = e.damager if (damager.uniqueId !== attacker.uniqueId || e.entity.uniqueId !== defender.uniqueId ) return val weapon = (damager as Player).inventory.itemInMainHand val weaponType = weapon.type var test = testQueue.remove() var expectedWeapon = test.weapon var expectedDamage = calculateExpectedDamage(expectedWeapon, test.armour) while (weaponType != expectedWeapon.type) { expectedDamage = calculateExpectedDamage(expectedWeapon, test.armour) plugin.logger.info("SKIPPED " + expectedWeapon.type + " Expected Damage: " + expectedDamage) if (expectedDamage == 0f) tally!!.passed() else tally!!.failed() test = testQueue.remove() expectedWeapon = test.weapon } if (wasFakeOverdamage(weapon) && e.isCancelled) { plugin.logger.info("PASSED Fake overdamage " + expectedDamage + " < " + (e.entity as LivingEntity).lastDamage) tally!!.passed() } else { val weaponMessage = "E: " + expectedWeapon.type.name + " A: " + weaponType.name assertEquals( expectedDamage, e.finalDamage.toFloat(), tally!!, weaponMessage, sender!! ) } } } Bukkit.getServer().pluginManager.registerEvents(listener, plugin) val testCount = testQueue.size.toLong() var attackDelay: Long = 0 for (test in testQueue) { attackDelay += test.attackDelay Bukkit.getScheduler().runTaskLater(plugin, Runnable { beforeEach() test.preparations.run() preparePlayer(test.weapon) attackCompat(attacker, defender) afterEach() }, attackDelay) } Bukkit.getScheduler().runTaskLater(plugin, Runnable { afterAll(testCount) EntityDamageByEntityEvent.getHandlerList().unregister(listener) }, attackDelay + 1) } private fun beforeAll() { plugin.logger.info("Running before all") for (player in listOfNotNull(attacker, defender)) { player.gameMode = GameMode.SURVIVAL player.maximumNoDamageTicks = 20 player.noDamageTicks = 0 // remove spawn invulnerability player.isInvulnerable = false } } private fun afterAll(testCount: Long) { fakeAttacker.removePlayer() fakeDefender.removePlayer() val missed = testCount - tally!!.total val message = String.format( "Passed: %d Failed: %d Total: %d Missed: %d", tally!!.passed, tally!!.failed, tally!!.total, missed ) plugin.logger.info(message) } private fun beforeEach() { for (player in listOfNotNull(attacker, defender)) { player.inventory.clear() player.exhaustion = 0f player.health = 20.0 } } private fun preparePlayer(weapon: ItemStack) { if (weapon.hasItemMeta()) { val meta = weapon.itemMeta val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() if (attackSpeedAttribute != null) { addAttributeModifierCompat(meta!!, attackSpeedAttribute, speedModifier) } weapon.setItemMeta(meta) } attacker.inventory.setItemInMainHand(weapon) attacker.updateInventory() val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val armourAttribute = XAttribute.ARMOR.get() val ai = attackDamageAttribute?.let { attacker.getAttribute(it) } val defenderArmour = armourAttribute?.let { defender.getAttribute(it) } if (attackDamageAttribute != null && ai != null) { getDefaultAttributeModifiersCompat(weapon, EquipmentSlot.HAND, attackDamageAttribute).forEach( Consumer { am: AttributeModifier? -> ai.removeModifier(am!!) ai.addModifier(am) }) } val armourContents = defender.inventory.armorContents plugin.logger.info( "Armour: " + Arrays.stream(armourContents).filter { obj: ItemStack? -> Objects.nonNull(obj) } .map { `is`: ItemStack -> `is`.type.name } .reduce { a: String, b: String -> "$a, $b" } .orElse("none") ) for (i in armourContents.indices) { val itemStack = armourContents[i] ?: continue val type = itemStack.type val slot = arrayOf( EquipmentSlot.FEET, EquipmentSlot.LEGS, EquipmentSlot.CHEST, EquipmentSlot.HEAD )[i] if (armourAttribute != null && defenderArmour != null) { for (attributeModifier in getDefaultAttributeModifiersCompat(itemStack, slot, armourAttribute)) { defenderArmour.removeModifier(attributeModifier) defenderArmour.addModifier(attributeModifier) } } } } private fun afterEach() { for (player in listOfNotNull(attacker, defender)) { player.exhaustion = 0f player.health = 20.0 } } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/InGameTesterIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.StringSpec import io.kotest.matchers.doubles.shouldBeExactly import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.EntityType import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class InGameTesterIntegrationTest : StringSpec({ val plugin = JavaPlugin.getPlugin(OCMTestMain::class.java) extension(MainThreadDispatcherExtension(plugin)) lateinit var attacker: Player lateinit var defender: Player lateinit var fakeAttacker: FakePlayer lateinit var fakeDefender: FakePlayer fun runSync(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(plugin, Callable { action() }).get() } fun preparePlayers() { println("Preparing players") val world = Bukkit.getServer().getWorld("world") // TODO might need to specify server superflat? val location = Location(world, 0.0, 100.0, 0.0) fakeAttacker = FakePlayer(plugin) fakeAttacker.spawn(location.add(2.0, 0.0, 0.0)) fakeDefender = FakePlayer(plugin) val defenderLocation = location.add(0.0, 0.0, 2.0) fakeDefender.spawn(defenderLocation) attacker = checkNotNull(Bukkit.getPlayer(fakeAttacker.uuid)) defender = checkNotNull(Bukkit.getPlayer(fakeDefender.uuid)) // Turn defender to face attacker defenderLocation.yaw = 180f defenderLocation.pitch = 0f defender.teleport(defenderLocation) // modeset of attacker takes precedence var playerData = getPlayerData(attacker.uniqueId) playerData.setModesetForWorld(attacker.world.uid, "old") setPlayerData(attacker.uniqueId, playerData) playerData = getPlayerData(defender.uniqueId) playerData.setModesetForWorld(defender.world.uid, "new") setPlayerData(defender.uniqueId, playerData) } beforeSpec { plugin.logger.info("Running before all") runSync { preparePlayers() } } beforeTest { runSync { for (player in listOfNotNull(attacker, defender)) { player.gameMode = GameMode.SURVIVAL player.maximumNoDamageTicks = 20 player.noDamageTicks = 0 // remove spawn invulnerability player.isInvulnerable = false } } } afterSpec { plugin.logger.info("Running after all") runSync { fakeAttacker.removePlayer() fakeDefender.removePlayer() } } "test melee attacks" { println("Testing melee attack") val netheriteSword = runCatching { Material.valueOf("NETHERITE_SWORD") }.getOrNull() val weapon = ItemStack(netheriteSword ?: Material.STONE_SWORD) val victim = runSync { attacker.world.spawnEntity(attacker.location.clone().add(1.5, 0.0, 0.0), EntityType.ZOMBIE) as LivingEntity } try { runSync { attacker.inventory.setItemInMainHand(weapon) attacker.updateInventory() victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 } var damageEvents = 0 var sawExpectedWeaponAtDamage = false var sawMeleeCause = false var sawPositiveUncancelledDamage = false val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR) fun onEntityDamageByEntity(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId != attacker.uniqueId || event.entity.uniqueId != victim.uniqueId) { return } damageEvents += 1 sawExpectedWeaponAtDamage = (attacker.inventory.itemInMainHand.type == weapon.type) sawMeleeCause = event.cause == EntityDamageEvent.DamageCause.ENTITY_ATTACK || event.cause == EntityDamageEvent.DamageCause.ENTITY_SWEEP_ATTACK if (!event.isCancelled && event.finalDamage > 0.0) { sawPositiveUncancelledDamage = true } } } runSync { Bukkit.getPluginManager().registerEvents(listener, plugin) } val victimStartHealth = runSync { victim.health } var minimumVictimHealth = victimStartHealth try { repeat(12) { val damaged = runSync { attackCompat(attacker, victim) minimumVictimHealth = minOf(minimumVictimHealth, victim.health) minimumVictimHealth < victimStartHealth && sawPositiveUncancelledDamage } if (damaged) { return@repeat } delay(2 * 50L) } } finally { runSync { EntityDamageByEntityEvent.getHandlerList().unregister(listener) } } repeat(4) { runSync { minimumVictimHealth = minOf(minimumVictimHealth, victim.health) } if (minimumVictimHealth < victimStartHealth) { return@repeat } delay(50L) } @Suppress("DEPRECATION") // Deprecated API kept for older server compatibility in tests. runSync { attacker.health } shouldBeExactly runSync { attacker.maxHealth } sawPositiveUncancelledDamage shouldBe true (minimumVictimHealth < victimStartHealth) shouldBe true (damageEvents > 0) shouldBe true sawExpectedWeaponAtDamage shouldBe true sawMeleeCause shouldBe true } finally { runSync { victim.remove() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/InvulnerabilityDamageIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XMaterial import com.cryptomorin.xseries.XPotion import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeGreaterThanOrEqual import io.kotest.matchers.ints.shouldBeExactly import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.AttributeModifier import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.player.PlayerItemConsumeEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.PotionMeta import org.bukkit.plugin.java.JavaPlugin import org.bukkit.potion.PotionData import org.bukkit.potion.PotionEffect import org.bukkit.potion.PotionEffectType import org.bukkit.potion.PotionType import kotlinx.coroutines.delay import java.util.UUID import java.util.concurrent.Callable import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kotlin.math.abs @OptIn(ExperimentalKotest::class) class InvulnerabilityDamageIntegrationTest : FunSpec({ val plugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) extensions(MainThreadDispatcherExtension(plugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(plugin, Callable { action() null }).get() } } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(player: Player, item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) val expectedAmounts = modifiers .filter { it.operation == AttributeModifier.Operation.ADD_NUMBER } .map { it.amount } val knownWeaponAmounts = NewWeaponDamage.values() .map { it.damage.toDouble() - 1.0 } .filter { it > 0.0 } .toSet() fun matchesAmount(first: Double, second: Double): Boolean = abs(first - second) <= 0.0001 val existingModifiers = attackAttribute.modifiers.toList() existingModifiers .filter { it.operation == AttributeModifier.Operation.ADD_NUMBER && it.amount > 0.0 } .filter { modifier -> knownWeaponAmounts.any { matchesAmount(it, modifier.amount) } && expectedAmounts.none { expected -> matchesAmount(expected, modifier.amount) } } .forEach { attackAttribute.removeModifier(it) } modifiers.forEach { modifier -> val alreadyApplied = attackAttribute.modifiers.any { it.operation == modifier.operation && matchesAmount(it.amount, modifier.amount) } if (!alreadyApplied) { attackAttribute.addModifier(modifier) } } } fun equip(player: Player, item: ItemStack) { prepareWeapon(item) player.inventory.setItemInMainHand(item) applyAttackDamageModifiers(player, item) player.updateInventory() } fun spawnAttacker(location: Location): Pair { val fake = FakePlayer(plugin) fake.spawn(location) val player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.gameMode = GameMode.SURVIVAL player.isInvulnerable = false player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "old") setPlayerData(player.uniqueId, playerData) return fake to player } fun spawnVictim(location: Location): LivingEntity { val world = location.world ?: error("World missing for victim spawn") return world.spawn(location, org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } fun createWeaknessPotion(): ItemStack { val item = ItemStack(Material.POTION) val meta = item.itemMeta as PotionMeta try { meta.basePotionType = PotionType.WEAKNESS } catch (e: NoSuchMethodError) { @Suppress("DEPRECATION") // Required for legacy server compatibility. meta.basePotionData = PotionData(PotionType.WEAKNESS, false, false) } item.itemMeta = meta return item } fun consumeWeaknessPotion(player: Player): PotionEffect { val item = createWeaknessPotion() val ctor = PlayerItemConsumeEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 3 && Player::class.java.isAssignableFrom(params[0]) && ItemStack::class.java.isAssignableFrom(params[1]) && EquipmentSlot::class.java.isAssignableFrom(params[2]) } val event = if (ctor != null) { ctor.newInstance(player, item, EquipmentSlot.HAND) as PlayerItemConsumeEvent } else { PlayerItemConsumeEvent(player, item) } Bukkit.getPluginManager().callEvent(event) val meta = event.item.itemMeta as PotionMeta return meta.customEffects.firstOrNull { it.type == PotionEffectType.WEAKNESS } ?: error("Weakness effect missing from potion meta") } test("second hit in the same tick should still fire inside invulnerability").config( enabled = false ) { // Disabled: current vanilla pipeline drops same-tick follow-up hits during invulnerability. // We will revisit once the intended behaviour is defined across versions. val events = mutableListOf() lateinit var attacker1: Player lateinit var attacker2: Player var victim: LivingEntity? = null var fake1: FakePlayer? = null var fake2: FakePlayer? = null val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && (event.damager.uniqueId == attacker1.uniqueId || event.damager.uniqueId == attacker2.uniqueId) ) { events.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attacker1Location = Location(world, 0.0, 100.0, 0.0) val attacker2Location = Location(world, 0.0, 100.0, 2.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnAttacker(attacker1Location) val (fakeB, playerB) = spawnAttacker(attacker2Location) fake1 = fakeA fake2 = fakeB attacker1 = playerA attacker2 = playerB val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim Bukkit.getPluginManager().registerEvents(listener, plugin) equip(attacker1, ItemStack(Material.DIAMOND_SWORD)) equip(attacker2, ItemStack(Material.STONE_SWORD)) attackCompat(attacker1, spawnedVictim) attackCompat(attacker2, spawnedVictim) val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attacker1Damage = attackDamageAttribute?.let { attacker1.getAttribute(it)?.value } val attacker2Damage = attackDamageAttribute?.let { attacker2.getAttribute(it)?.value } plugin.logger.info( "Invuln same-tick debug: events=${events.size} " + "noDamageTicks=${spawnedVictim.noDamageTicks} lastDamage=${spawnedVictim.lastDamage} " + "attacker1Damage=$attacker1Damage attacker2Damage=$attacker2Damage" ) } delayTicks(3) runSync { val currentVictim = checkNotNull(victim) plugin.logger.info( "Invuln same-tick debug (post): events=${events.size} " + "noDamageTicks=${currentVictim.noDamageTicks} lastDamage=${currentVictim.lastDamage} " + "lastEventDamage=${events.lastOrNull()?.damage} lastEventFinal=${events.lastOrNull()?.finalDamage}" ) } events.size.shouldBeExactly(2) } finally { HandlerList.unregisterAll(listener) runSync { fake1?.removePlayer() fake2?.removePlayer() victim?.remove() } } } test("slightly higher base damage inside invulnerability should fire") .config(enabled = false) { // Ignored for now: behaviour differs across versions and is not addressed yet. val events = mutableListOf() lateinit var attacker: Player var victim: LivingEntity? = null var fake: FakePlayer? = null val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { events.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnAttacker(attackerLocation) fake = fakeA attacker = playerA val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim Bukkit.getPluginManager().registerEvents(listener, plugin) val woodenSword = XMaterial.WOODEN_SWORD.parseItem() ?: error("WOODEN_SWORD material not available") equip(attacker, woodenSword) attackCompat(attacker, spawnedVictim) val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attackerDamage = attackDamageAttribute?.let { attacker.getAttribute(it)?.value } plugin.logger.info( "Invuln overdamage debug (first hit): events=${events.size} " + "noDamageTicks=${spawnedVictim.noDamageTicks} lastDamage=${spawnedVictim.lastDamage} " + "attackerDamage=$attackerDamage" ) } delayTicks(2) runSync { val currentVictim = checkNotNull(victim) val firstDamage = events.firstOrNull()?.damage ?: error("Expected a damage event from the first hit") currentVictim.noDamageTicks = currentVictim.maximumNoDamageTicks currentVictim.lastDamage = firstDamage val stoneSword = XMaterial.STONE_SWORD.parseItem() ?: error("STONE_SWORD material not available") equip(attacker, stoneSword) attackCompat(attacker, currentVictim) val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attackerDamage = attackDamageAttribute?.let { attacker.getAttribute(it)?.value } plugin.logger.info( "Invuln overdamage debug (second hit): events=${events.size} " + "noDamageTicks=${currentVictim.noDamageTicks} lastDamage=${currentVictim.lastDamage} " + "attackerDamage=$attackerDamage firstDamage=$firstDamage" ) } delayTicks(2) runSync { val currentVictim = checkNotNull(victim) plugin.logger.info( "Invuln overdamage debug (post): events=${events.size} " + "noDamageTicks=${currentVictim.noDamageTicks} lastDamage=${currentVictim.lastDamage} " + "lastEventDamage=${events.lastOrNull()?.damage} lastEventFinal=${events.lastOrNull()?.finalDamage}" ) } events.size.shouldBeExactly(2) } finally { HandlerList.unregisterAll(listener) runSync { fake?.removePlayer() victim?.remove() } } } test("clearly higher base damage inside invulnerability should fire") { val events = mutableListOf() lateinit var attacker: Player var victim: LivingEntity? = null var fake: FakePlayer? = null val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { events.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnAttacker(attackerLocation) fake = fakeA attacker = playerA val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim Bukkit.getPluginManager().registerEvents(listener, plugin) val woodenSword = XMaterial.WOODEN_SWORD.parseItem() ?: error("WOODEN_SWORD material not available") equip(attacker, woodenSword) attackCompat(attacker, spawnedVictim) val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attackerDamage = attackDamageAttribute?.let { attacker.getAttribute(it)?.value } plugin.logger.info( "Invuln overdamage (iron) debug (first hit): events=${events.size} " + "noDamageTicks=${spawnedVictim.noDamageTicks} lastDamage=${spawnedVictim.lastDamage} " + "attackerDamage=$attackerDamage" ) } delayTicks(2) runSync { val currentVictim = checkNotNull(victim) val firstDamage = events.firstOrNull()?.damage ?: error("Expected a damage event from the first hit") currentVictim.noDamageTicks = currentVictim.maximumNoDamageTicks currentVictim.lastDamage = firstDamage val ironSword = XMaterial.IRON_SWORD.parseItem() ?: error("IRON_SWORD material not available") equip(attacker, ironSword) attackCompat(attacker, currentVictim) val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val attackerDamage = attackDamageAttribute?.let { attacker.getAttribute(it)?.value } plugin.logger.info( "Invuln overdamage (iron) debug (second hit): events=${events.size} " + "noDamageTicks=${currentVictim.noDamageTicks} lastDamage=${currentVictim.lastDamage} " + "attackerDamage=$attackerDamage firstDamage=$firstDamage" ) } delayTicks(2) runSync { val currentVictim = checkNotNull(victim) plugin.logger.info( "Invuln overdamage (iron) debug (post): events=${events.size} " + "noDamageTicks=${currentVictim.noDamageTicks} lastDamage=${currentVictim.lastDamage} " + "lastEventDamage=${events.lastOrNull()?.damage} lastEventFinal=${events.lastOrNull()?.finalDamage}" ) } events.size.shouldBeExactly(2) } finally { HandlerList.unregisterAll(listener) runSync { fake?.removePlayer() victim?.remove() } } } test("zero vanilla damage should still fire after lastDamage reset").config( enabled = false ) { // Disabled: behaviour diverges across versions; we will revisit once vanilla expectations are finalised. val events = mutableListOf() lateinit var attacker: Player var victim: LivingEntity? = null var fake: FakePlayer? = null val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId == currentVictim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { events.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnAttacker(attackerLocation) fake = fakeA attacker = playerA val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim Bukkit.getPluginManager().registerEvents(listener, plugin) equip(attacker, ItemStack(Material.DIAMOND_SWORD)) attackCompat(attacker, spawnedVictim) } delayTicks(2) // allow MONITOR handler to set lastDamage to 0 runSync { val currentVictim = checkNotNull(victim) currentVictim.noDamageTicks = currentVictim.maximumNoDamageTicks currentVictim.lastDamage.shouldBe(0.0) val effect = consumeWeaknessPotion(attacker) attacker.addPotionEffect(effect, true) val woodenSword = XMaterial.WOODEN_SWORD.parseItem() ?: ItemStack(Material.STONE_SWORD) equip(attacker, woodenSword) attackCompat(attacker, currentVictim) } delayTicks(3) events.size.shouldBeExactly(2) } finally { HandlerList.unregisterAll(listener) runSync { fake?.removePlayer() victim?.remove() } } } test("weakness should not store negative last damage values") { var attacker: Player? = null var victim: LivingEntity? = null var fake: FakePlayer? = null var edbelListener: Listener? = null var lastDamagesField: java.lang.reflect.Field? = null var damageEvents = 0 val damageListener = object : Listener { @EventHandler(ignoreCancelled = false) fun onDamage(event: EntityDamageByEntityEvent) { val currentVictim = victim ?: return val currentAttacker = attacker ?: return if (event.entity.uniqueId != currentVictim.uniqueId) return if (event.damager.uniqueId != currentAttacker.uniqueId) return damageEvents += 1 } } val oldWeaknessModifier = ocm.config.getDouble("old-potion-effects.weakness.modifier") val oldWeaknessMultiplier = ocm.config.getBoolean("old-potion-effects.weakness.multiplier") try { runSync { ocm.config.set("old-potion-effects.weakness.modifier", -10.0) ocm.config.set("old-potion-effects.weakness.multiplier", false) ocm.saveConfig() Config.reload() edbelListener = HandlerList.getRegisteredListeners(ocm) .map { it.listener } .firstOrNull { it.javaClass.name.endsWith("EntityDamageByEntityListener") } ?: error("EntityDamageByEntityListener not registered") lastDamagesField = edbelListener?.javaClass?.getDeclaredField("lastDamages")?.apply { isAccessible = true } ?: error("Failed to resolve lastDamages field") val world = checkNotNull(Bukkit.getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.2, 100.0, 0.0) val (fakeA, playerA) = spawnAttacker(attackerLocation) fake = fakeA attacker = playerA val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim Bukkit.getPluginManager().registerEvents(damageListener, plugin) val effect = consumeWeaknessPotion(playerA) playerA.addPotionEffect(effect, true) equip(playerA, ItemStack(Material.IRON_SWORD)) attackCompat(playerA, spawnedVictim) val currentVictim = checkNotNull(victim) @Suppress("UNCHECKED_CAST") val lastDamages = lastDamagesField?.get(edbelListener) as Map val stored = lastDamages[currentVictim.uniqueId] ?: error("No stored last damage for victim (events=$damageEvents)") damageEvents.shouldBeExactly(1) stored.shouldBeGreaterThanOrEqual(0.0) } } finally { HandlerList.unregisterAll(damageListener) runSync { ocm.config.set("old-potion-effects.weakness.modifier", oldWeaknessModifier) ocm.config.set("old-potion-effects.weakness.multiplier", oldWeaknessMultiplier) ocm.saveConfig() Config.reload() fake?.removePlayer() victim?.remove() } } } test("environmental damage above baseline should apply during invulnerability") { var victim: LivingEntity? = null var edbelListener: Listener? = null var lastDamagesField: java.lang.reflect.Field? = null var capturedEvent: EntityDamageEvent? = null val eventListener = object : Listener { @EventHandler(ignoreCancelled = false) fun onDamage(event: EntityDamageEvent) { val currentVictim = victim ?: return if (event.entity.uniqueId != currentVictim.uniqueId) return if (event is EntityDamageByEntityEvent) return capturedEvent = event } } try { runSync { edbelListener = HandlerList.getRegisteredListeners(ocm) .map { it.listener } .firstOrNull { it.javaClass.name.endsWith("EntityDamageByEntityListener") } ?: error("EntityDamageByEntityListener not registered") lastDamagesField = edbelListener?.javaClass?.getDeclaredField("lastDamages")?.apply { isAccessible = true } ?: error("Failed to resolve lastDamages field") val world = checkNotNull(Bukkit.getWorld("world")) val victimLocation = Location(world, 1.2, 100.0, 0.0) val spawnedVictim = spawnVictim(victimLocation) victim = spawnedVictim spawnedVictim.maximumNoDamageTicks = 20 spawnedVictim.noDamageTicks = 20 spawnedVictim.lastDamage = 0.0 @Suppress("UNCHECKED_CAST") val lastDamages = lastDamagesField?.get(edbelListener) as MutableMap lastDamages[spawnedVictim.uniqueId] = 5.0 Bukkit.getPluginManager().registerEvents(eventListener, plugin) val event = EntityDamageEvent( spawnedVictim, EntityDamageEvent.DamageCause.FALL, 12.0 ) Bukkit.getPluginManager().callEvent(event) } runSync { val event = checkNotNull(capturedEvent) event.isCancelled.shouldBe(false) event.damage.shouldBe(7.0) } } finally { HandlerList.unregisterAll(eventListener) runSync { @Suppress("UNCHECKED_CAST") val lastDamages = lastDamagesField?.get(edbelListener) as? MutableMap lastDamages?.remove(victim?.uniqueId) victim?.remove() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/KotestRunner.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.github.ajalt.mordant.TermColors import io.kotest.common.ExperimentalKotest import io.kotest.common.KotestInternal import io.kotest.core.config.AbstractProjectConfig import io.kotest.core.extensions.TestCaseExtension import io.kotest.core.spec.IsolationMode import io.kotest.core.test.TestCase import io.kotest.core.test.TestCaseOrder import io.kotest.core.test.TestResult import io.kotest.engine.TestEngineLauncher import io.kotest.engine.listener.AbstractTestEngineListener import io.kotest.engine.listener.CompositeTestEngineListener import io.kotest.engine.listener.EnhancedConsoleTestEngineListener import kotlinx.coroutines.CoroutineDispatcher import kotlinx.coroutines.withContext import org.bukkit.Bukkit import org.bukkit.plugin.java.JavaPlugin import kotlin.coroutines.CoroutineContext import kotlin.coroutines.coroutineContext @OptIn(ExperimentalKotest::class) object KotestProjectConfig : AbstractProjectConfig() { override val isolationMode = IsolationMode.SingleInstance override val concurrentSpecs = 1 override val concurrentTests = 1 override val testCaseOrder = TestCaseOrder.Sequential } class BukkitMainThreadDispatcher( private val plugin: JavaPlugin, ) : CoroutineDispatcher() { override fun dispatch( context: CoroutineContext, block: Runnable, ) { Bukkit.getScheduler().runTask(plugin, block) } } class MainThreadDispatcherExtension( private val plugin: JavaPlugin, ) : TestCaseExtension { override suspend fun intercept( testCase: TestCase, execute: suspend (TestCase) -> TestResult, ): TestResult { val dispatcher = BukkitMainThreadDispatcher(plugin) val newContext = coroutineContext + dispatcher return withContext(newContext) { execute(testCase) } } } object KotestRunner { @OptIn(KotestInternal::class) @JvmStatic fun run(plugin: JavaPlugin) { // Schedule test asynchronously to avoid deadlock. Bukkit.getScheduler().runTaskAsynchronously( plugin, Runnable { try { var hasFailures = false val failureLines = ArrayList(16) fun throwableFromResult(result: TestResult): Throwable? { // Avoid depending on Kotest internals: fetch any Throwable via reflection for cross-version tolerance. val candidateGetters = listOf( "getErrorOrNull", "getCauseOrNull", "getThrowableOrNull", "getFailureOrNull", ) for (getter in candidateGetters) { val m = result::class.java.methods.firstOrNull { it.name == getter && it.parameterCount == 0 } ?: continue val t = runCatching { m.invoke(result) }.getOrNull() as? Throwable if (t != null) return t } return null } fun formatFailure( testCase: TestCase, result: TestResult, ): String { val specName = testCase.spec::class.qualifiedName ?: testCase.spec::class.java.name val testName = testCase.displayName val t = throwableFromResult(result) if (t == null) return "$specName, $testName" val message = t.message ?.lineSequence() ?.firstOrNull() ?.trim() .orEmpty() val head = if (message.isNotEmpty()) "${t::class.java.simpleName}: $message" else t::class.java.simpleName val frame = t.stackTrace.firstOrNull() val at = if (frame != null) " (${frame.fileName}:${frame.lineNumber})" else "" return "$specName, $testName -- $head$at" } val listener = object : AbstractTestEngineListener() { override suspend fun testFinished( testCase: TestCase, result: TestResult, ) { if (result.isFailure || result.isError) { hasFailures = true if (failureLines.size < 25) { failureLines.add(formatFailure(testCase, result)) } } } override suspend fun engineFinished(t: List) { val success = t.isEmpty() && !hasFailures TestResultWriter.writeFailureSummary(plugin, failureLines) TestResultWriter.writeAndShutdown(plugin, success) } } val compositeListener = CompositeTestEngineListener( listOf( EnhancedConsoleTestEngineListener(TermColors()), listener, ), ) TestEngineLauncher() .withListener(compositeListener) .withProjectConfig(KotestProjectConfig) .withClasses( ConfigMigrationIntegrationTest::class, ModesetRulesIntegrationTest::class, DisableOffhandIntegrationTest::class, DisableOffhandReflectionIntegrationTest::class, InGameTesterIntegrationTest::class, CopperToolsIntegrationTest::class, OldPotionEffectsIntegrationTest::class, InvulnerabilityDamageIntegrationTest::class, FireAspectOverdamageIntegrationTest::class, OldCriticalHitsIntegrationTest::class, OldToolDamageMobIntegrationTest::class, WeaponDurabilityIntegrationTest::class, GoldenAppleIntegrationTest::class, OldArmourDurabilityIntegrationTest::class, PlayerKnockbackIntegrationTest::class, AttackCooldownTrackerIntegrationTest::class, AttackCooldownHeldItemIntegrationTest::class, PlayerRegenIntegrationTest::class, FishingRodVelocityIntegrationTest::class, SwordSweepIntegrationTest::class, PacketCancellationIntegrationTest::class, EnderpearlCooldownIntegrationTest::class, SpigotFunctionChooserIntegrationTest::class, ChorusFruitIntegrationTest::class, CustomWeaponDamageIntegrationTest::class, ToolDamageTooltipIntegrationTest::class, SwordBlockingIntegrationTest::class, ConsumableComponentIntegrationTest::class, PaperSwordBlockingDamageReductionIntegrationTest::class, AttackRangeIntegrationTest::class, ).launch() } catch (e: Throwable) { plugin.logger.severe("Failed to execute Kotest runner: ${e.message}") TestResultWriter.writeAndShutdown(plugin, false, e) } }, ) } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/LegacyFakePlayer12.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.mojang.authlib.GameProfile import io.netty.channel.ChannelInboundHandlerAdapter import io.netty.channel.embedded.EmbeddedChannel import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.entity.Player import org.bukkit.event.player.AsyncPlayerPreLoginEvent import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerPreLoginEvent import org.bukkit.event.player.PlayerQuitEvent import org.bukkit.plugin.java.JavaPlugin import java.lang.reflect.Field import java.lang.reflect.Method import java.net.InetAddress import java.util.UUID internal class LegacyFakePlayer12( private val plugin: JavaPlugin, val uuid: UUID, val name: String ) { private val cbVersion: String = Bukkit.getServer().javaClass.`package`.name.substringAfterLast('.') var entityPlayer: Any? = null private set var bukkitPlayer: Player? = null private set private fun nmsClass(simpleName: String): Class<*> = Class.forName("net.minecraft.server.$cbVersion.$simpleName") private fun craftClass(simpleName: String): Class<*> = Class.forName("org.bukkit.craftbukkit.$cbVersion.$simpleName") fun spawn(location: Location) { plugin.logger.info("Spawn: Starting (legacy $cbVersion)") val world = location.world ?: throw IllegalArgumentException("Location has no world!") val craftWorld = craftClass("CraftWorld").cast(world) val worldServer = craftWorld.javaClass.getMethod("getHandle").invoke(craftWorld) val craftServer = craftClass("CraftServer").cast(Bukkit.getServer()) val minecraftServer = craftServer.javaClass.getMethod("getServer").invoke(craftServer) val entityPlayer = createEntityPlayer(minecraftServer, worldServer) this.entityPlayer = entityPlayer val bukkitPlayer = entityPlayer.javaClass.getMethod("getBukkitEntity").invoke(entityPlayer) as Player this.bukkitPlayer = bukkitPlayer firePreLoginEvents() val playerList = minecraftServer.javaClass.getMethod("getPlayerList").invoke(minecraftServer) invokeMethodIfExists(playerList, "a", entityPlayer) setPositionRotation(entityPlayer, location) setDataWatcherFlags(entityPlayer) spawnInWorld(entityPlayer, worldServer) setGameMode(entityPlayer, worldServer) setupConnection(entityPlayer, minecraftServer) addToPlayerChunkMap(worldServer, entityPlayer) addToPlayerList(playerList, entityPlayer) updatePlayerListMaps(playerList, entityPlayer) val joinMessage = "§e$name joined the game" val joinEvent = PlayerJoinEvent(bukkitPlayer, joinMessage) Bukkit.getPluginManager().callEvent(joinEvent) broadcastMessage(joinEvent.joinMessage) sendSpawnPackets(entityPlayer) addEntityToWorld(worldServer, entityPlayer) Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, Runnable { runCatching { invokeMethod(entityPlayer, "playerTick") } }, 1L, 1L) plugin.logger.info("Spawn: completed successfully (legacy)") } fun removePlayer() { val entityPlayer = entityPlayer ?: return val bukkitPlayer = bukkitPlayer ?: return val craftServer = craftClass("CraftServer").cast(Bukkit.getServer()) val minecraftServer = craftServer.javaClass.getMethod("getServer").invoke(craftServer) val playerList = minecraftServer.javaClass.getMethod("getPlayerList").invoke(minecraftServer) val quitMessage = "§e$name left the game" val quitEvent = PlayerQuitEvent(bukkitPlayer, quitMessage) Bukkit.getPluginManager().callEvent(quitEvent) val worldServer = getWorldServer(entityPlayer) val playerChunkMap = getPlayerChunkMap(worldServer) invokeMethodIfExists(playerChunkMap, "removePlayer", entityPlayer) invokeMethodIfExists(worldServer, "removeEntity", entityPlayer) bukkitPlayer.kickPlayer(quitMessage) removeFromPlayerList(playerList, entityPlayer) removeFromPlayerMaps(playerList, entityPlayer) sendRemovePackets(entityPlayer) invokeMethodIfExists(playerList, "savePlayerFile", entityPlayer) } fun startUsingOffhand() { val entityPlayer = entityPlayer ?: return val enumHandClass = nmsClass("EnumHand") val offHand = enumValue(enumHandClass, "OFF_HAND") val candidateNames = arrayOf("c", "a", "startUsingItem") for (name in candidateNames) { val method = findMethod(entityPlayer.javaClass, name, arrayOf(offHand), ignoreMissing = true) if (method != null) { method.invoke(entityPlayer, offHand) return } } val fallback = entityPlayer.javaClass.methods.firstOrNull { method -> method.parameterTypes.size == 1 && method.parameterTypes[0] == enumHandClass } fallback?.invoke(entityPlayer, offHand) } fun getConnection(serverPlayer: Any): Any { val connectionField = findField(serverPlayer.javaClass, "playerConnection") ?: throw NoSuchFieldException("playerConnection not found on ${serverPlayer.javaClass.name}") return connectionField.get(serverPlayer) } private fun createEntityPlayer(minecraftServer: Any, worldServer: Any): Any { val entityPlayerClass = nmsClass("EntityPlayer") val playerInteractManagerClass = nmsClass("PlayerInteractManager") val pimCtor = playerInteractManagerClass.constructors.firstOrNull { ctor -> ctor.parameterTypes.size == 1 && ctor.parameterTypes[0].isAssignableFrom(worldServer.javaClass) } ?: playerInteractManagerClass.constructors.first() val playerInteractManager = pimCtor.newInstance(worldServer) val gameProfile = GameProfile(uuid, name) val ctor = entityPlayerClass.constructors.firstOrNull { ctor -> val params = ctor.parameterTypes params.size == 4 && params[0].isAssignableFrom(minecraftServer.javaClass) && params[1].isAssignableFrom(worldServer.javaClass) && params[2] == GameProfile::class.java && params[3].isAssignableFrom(playerInteractManagerClass) } ?: entityPlayerClass.constructors.first() return ctor.newInstance(minecraftServer, worldServer, gameProfile, playerInteractManager) } private fun firePreLoginEvents() { try { val address = InetAddress.getByName("127.0.0.1") val asyncPreLogin = AsyncPlayerPreLoginEvent(name, address, uuid) val preLogin = PlayerPreLoginEvent(name, address, uuid) Thread { Bukkit.getPluginManager().callEvent(asyncPreLogin) }.start() Bukkit.getPluginManager().callEvent(preLogin) } catch (e: Exception) { plugin.logger.warning("Failed to fire pre-login events: ${e.message}") } } private fun setPositionRotation(entityPlayer: Any, location: Location) { val method = entityPlayer.javaClass.getMethod( "setPositionRotation", Double::class.javaPrimitiveType, Double::class.javaPrimitiveType, Double::class.javaPrimitiveType, Float::class.javaPrimitiveType, Float::class.javaPrimitiveType ) method.invoke( entityPlayer, location.x, location.y, location.z, location.yaw, location.pitch ) } private fun setDataWatcherFlags(entityPlayer: Any) { runCatching { val dataWatcher = invokeMethod(entityPlayer, "getDataWatcher") val dataWatcherRegistryClass = nmsClass("DataWatcherRegistry") val serializer = dataWatcherRegistryClass.getField("a").get(null) val dataWatcherObject = invokeMethod(serializer, "a", 13) val setMethod = dataWatcher.javaClass.methods.firstOrNull { it.name == "set" && it.parameterCount == 2 } setMethod?.invoke(dataWatcher, dataWatcherObject, 127.toByte()) } } private fun spawnInWorld(entityPlayer: Any, worldServer: Any) { invokeMethodIfExists(entityPlayer, "spawnIn", worldServer) val playerInteractManager = findField(entityPlayer.javaClass, "playerInteractManager")?.get(entityPlayer) if (playerInteractManager != null) { invokeMethodIfExists(playerInteractManager, "a", worldServer) } } private fun setGameMode(entityPlayer: Any, worldServer: Any) { val playerInteractManager = findField(entityPlayer.javaClass, "playerInteractManager")?.get(entityPlayer) ?: return val enumGamemodeClass = nmsClass("EnumGamemode") val gameMode = Bukkit.getServer().defaultGameMode val enumValue = enumValue(enumGamemodeClass, gameMode) invokeMethodIfExists(playerInteractManager, "b", enumValue) } private fun setupConnection(entityPlayer: Any, minecraftServer: Any) { val networkManagerClass = nmsClass("NetworkManager") val enumProtocolDirectionClass = nmsClass("EnumProtocolDirection") val serverbound = enumValue(enumProtocolDirectionClass, "SERVERBOUND") val networkManager = networkManagerClass .getConstructor(enumProtocolDirectionClass) .newInstance(serverbound) val playerConnectionClass = nmsClass("PlayerConnection") val pcCtor = playerConnectionClass.constructors.firstOrNull { ctor -> val params = ctor.parameterTypes params.size == 3 && params[0].isAssignableFrom(minecraftServer.javaClass) && params[1].isAssignableFrom(networkManagerClass) && params[2].isAssignableFrom(entityPlayer.javaClass) } ?: playerConnectionClass.constructors.first() val playerConnection = pcCtor.newInstance(minecraftServer, networkManager, entityPlayer) setFieldValue(entityPlayer, "playerConnection", playerConnection) val channel = EmbeddedChannel(ChannelInboundHandlerAdapter()) setFieldValue(networkManager, "channel", channel) runCatching { channel.close() } } private fun addToPlayerChunkMap(worldServer: Any, entityPlayer: Any) { val playerChunkMap = getPlayerChunkMap(worldServer) invokeMethodIfExists(playerChunkMap, "addPlayer", entityPlayer) } private fun addToPlayerList(playerList: Any, entityPlayer: Any) { runCatching { val playersField = findField(playerList.javaClass, "players") @Suppress("UNCHECKED_CAST") val players = playersField?.get(playerList) as? MutableCollection players?.add(entityPlayer) } } private fun updatePlayerListMaps(playerList: Any, entityPlayer: Any) { runCatching { val byUuidField = findField(playerList.javaClass, "j") @Suppress("UNCHECKED_CAST") val byUuid = byUuidField?.get(playerList) as? MutableMap byUuid?.put(uuid, entityPlayer) } runCatching { val byNameField = findField(playerList.javaClass, "playersByName") @Suppress("UNCHECKED_CAST") val byName = byNameField?.get(playerList) as? MutableMap byName?.put(name, entityPlayer) } } private fun sendSpawnPackets(entityPlayer: Any) { val packetPlayOutPlayerInfo = nmsClass("PacketPlayOutPlayerInfo") val actionClass = nmsClass("PacketPlayOutPlayerInfo\$EnumPlayerInfoAction") val addAction = enumValue(actionClass, "ADD_PLAYER") val entityArray = java.lang.reflect.Array.newInstance(entityPlayer.javaClass, 1) java.lang.reflect.Array.set(entityArray, 0, entityPlayer) val infoPacket = packetPlayOutPlayerInfo .getConstructor(actionClass, entityArray.javaClass) .newInstance(addAction, entityArray) val namedSpawnPacket = createSingleArgPacket("PacketPlayOutNamedEntitySpawn", entityPlayer) val craftPlayerClass = craftClass("entity.CraftPlayer") for (player in Bukkit.getOnlinePlayers()) { val craftPlayer = craftPlayerClass.cast(player) val handle = craftPlayerClass.getMethod("getHandle").invoke(craftPlayer) val connection = findField(handle.javaClass, "playerConnection")?.get(handle) ?: continue sendPacket(connection, infoPacket) if (namedSpawnPacket != null) { sendPacket(connection, namedSpawnPacket) } } } private fun sendRemovePackets(entityPlayer: Any) { val packetDestroy = createEntityDestroyPacket(entityPlayer) val packetInfo = createPlayerInfoPacket("REMOVE_PLAYER", entityPlayer) val craftPlayerClass = craftClass("entity.CraftPlayer") for (player in Bukkit.getOnlinePlayers()) { val craftPlayer = craftPlayerClass.cast(player) val handle = craftPlayerClass.getMethod("getHandle").invoke(craftPlayer) val connection = findField(handle.javaClass, "playerConnection")?.get(handle) ?: continue if (packetDestroy != null) sendPacket(connection, packetDestroy) if (packetInfo != null) sendPacket(connection, packetInfo) } } private fun createPlayerInfoPacket(actionName: String, entityPlayer: Any): Any? { return runCatching { val packetPlayOutPlayerInfo = nmsClass("PacketPlayOutPlayerInfo") val actionClass = nmsClass("PacketPlayOutPlayerInfo\$EnumPlayerInfoAction") val action = enumValue(actionClass, actionName) val entityArray = java.lang.reflect.Array.newInstance(entityPlayer.javaClass, 1) java.lang.reflect.Array.set(entityArray, 0, entityPlayer) packetPlayOutPlayerInfo .getConstructor(actionClass, entityArray.javaClass) .newInstance(action, entityArray) }.getOrNull() } private fun createEntityDestroyPacket(entityPlayer: Any): Any? { return runCatching { val packetClass = nmsClass("PacketPlayOutEntityDestroy") val getIdMethod = entityPlayer.javaClass.getMethod("getId") val entityId = getIdMethod.invoke(entityPlayer) as Int val ids = intArrayOf(entityId) packetClass.getConstructor(IntArray::class.java).newInstance(ids) }.getOrNull() } private fun createSingleArgPacket(className: String, entityPlayer: Any): Any? { return runCatching { val packetClass = nmsClass(className) val ctor = packetClass.constructors.firstOrNull { ctor -> ctor.parameterTypes.size == 1 && ctor.parameterTypes[0].isAssignableFrom(entityPlayer.javaClass) } ?: packetClass.constructors.firstOrNull { ctor -> ctor.parameterTypes.size == 1 && ctor.parameterTypes[0].isAssignableFrom(entityPlayer.javaClass.superclass) } ctor?.newInstance(entityPlayer) }.getOrNull() } private fun addEntityToWorld(worldServer: Any, entityPlayer: Any) { invokeMethodIfExists(worldServer, "addEntity", entityPlayer) } private fun getWorldServer(entityPlayer: Any): Any { val worldField = findField(entityPlayer.javaClass, "world") return worldField?.get(entityPlayer) ?: invokeMethod(entityPlayer, "getWorld") } private fun getPlayerChunkMap(worldServer: Any): Any { val getPlayerChunkMap = worldServer.javaClass.methods.firstOrNull { it.name == "getPlayerChunkMap" } return if (getPlayerChunkMap != null) { getPlayerChunkMap.invoke(worldServer) } else { findField(worldServer.javaClass, "playerChunkMap")?.get(worldServer) ?: throw NoSuchFieldException("playerChunkMap not found on ${worldServer.javaClass.name}") } } private fun removeFromPlayerList(playerList: Any, entityPlayer: Any) { runCatching { val playersField = findField(playerList.javaClass, "players") @Suppress("UNCHECKED_CAST") val players = playersField?.get(playerList) as? MutableCollection players?.remove(entityPlayer) } } private fun removeFromPlayerMaps(playerList: Any, entityPlayer: Any) { runCatching { val byUuidField = findField(playerList.javaClass, "j") @Suppress("UNCHECKED_CAST") val byUuid = byUuidField?.get(playerList) as? MutableMap byUuid?.remove(uuid) } runCatching { val byNameField = findField(playerList.javaClass, "playersByName") @Suppress("UNCHECKED_CAST") val byName = byNameField?.get(playerList) as? MutableMap byName?.remove(name) } } private fun sendPacket(connection: Any, packet: Any) { val packetClass = nmsClass("Packet") val sendMethod = connection.javaClass.getMethod("sendPacket", packetClass) sendMethod.invoke(connection, packet) } private fun broadcastMessage(message: String?) { if (message.isNullOrEmpty()) return for (player in Bukkit.getOnlinePlayers()) { player.sendMessage(message) } } private fun invokeMethod(target: Any, name: String, vararg args: Any?): Any { val method = findMethod(target.javaClass, name, args) ?: throw NoSuchMethodException("Method '$name' not found on ${target.javaClass.name}") return method.invoke(target, *args) } private fun invokeMethodIfExists(target: Any, name: String, vararg args: Any?) { val method = findMethod(target.javaClass, name, args, ignoreMissing = true) ?: return method.invoke(target, *args) } private fun findMethod( clazz: Class<*>, name: String, args: Array, ignoreMissing: Boolean = false ): Method? { val candidates = (clazz.methods + clazz.declaredMethods).filter { it.name == name } val method = candidates.firstOrNull { method -> if (method.parameterTypes.size != args.size) return@firstOrNull false method.parameterTypes.indices.all { idx -> val arg = args[idx] arg == null || method.parameterTypes[idx].isAssignableFrom(arg.javaClass) } } ?: candidates.firstOrNull { it.parameterTypes.size == args.size } if (method == null && !ignoreMissing) { throw NoSuchMethodException("Method '$name' not found on ${clazz.name}") } method?.isAccessible = true return method } private fun findField(clazz: Class<*>, name: String): Field? { var current: Class<*>? = clazz while (current != null) { runCatching { val field = current.getDeclaredField(name) field.isAccessible = true return field } current = current.superclass } return null } private fun setFieldValue(target: Any, name: String, value: Any?) { val field = findField(target.javaClass, name) ?: return field.set(target, value) } private fun enumValue(enumClass: Class<*>, name: String): Any { @Suppress("UNCHECKED_CAST") val enumType = enumClass as Class> return java.lang.Enum.valueOf(enumType, name) } private fun enumValue(enumClass: Class<*>, gameMode: GameMode): Any { return enumValue(enumClass, gameMode.name) } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/LegacyFakePlayer9.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.mojang.authlib.GameProfile import io.netty.channel.ChannelInboundHandlerAdapter import io.netty.channel.ChannelOutboundHandlerAdapter import io.netty.channel.embedded.EmbeddedChannel import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.entity.Player import org.bukkit.event.player.AsyncPlayerPreLoginEvent import org.bukkit.event.player.PlayerPreLoginEvent import org.bukkit.plugin.java.JavaPlugin import java.net.InetAddress import java.util.* /** * Fake player for 1.9.x (v1_9_R2). Uses PlayerList#a(NetworkManager, EntityPlayer) * so the server treats it like a real online player (damage/knockback events). */ internal class LegacyFakePlayer9( private val plugin: JavaPlugin, val uuid: UUID, val name: String ) { private val cbVersion: String = Bukkit.getServer().javaClass.`package`.name.substringAfterLast('.') var entityPlayer: Any? = null private set var bukkitPlayer: Player? = null private set private fun nms(simple: String): Class<*> = Class.forName("net.minecraft.server.$cbVersion.$simple", true, Bukkit.getServer().javaClass.classLoader) private fun craft(simple: String): Class<*> = Class.forName("org.bukkit.craftbukkit.$cbVersion.$simple", true, Bukkit.getServer().javaClass.classLoader) fun spawn(location: Location) { val world = location.world ?: error("Location has no world") val craftWorld = craft("CraftWorld").cast(world) val worldServer = craftWorld.javaClass.getMethod("getHandle").invoke(craftWorld) val craftServer = craft("CraftServer").cast(Bukkit.getServer()) val mcServer = craftServer.javaClass.getMethod("getServer").invoke(craftServer) val playerList = mcServer.javaClass.getMethod("getPlayerList").invoke(mcServer) val ep = createEntityPlayer(mcServer, worldServer) entityPlayer = ep bukkitPlayer = ep.javaClass.getMethod("getBukkitEntity").invoke(ep) as Player // Ensure NMS alive/dead flags are sane so Bukkit sees the player as valid. runCatching { val deadField = ep.javaClass.superclass.getDeclaredField("dead") deadField.isAccessible = true deadField.setBoolean(ep, false) } runCatching { val health = ep.javaClass.getMethod("setHealth", Float::class.javaPrimitiveType) health.invoke(ep, 20.0f) } firePreLogin() setPosition(ep, location) setGameMode(ep) setVulnerability(ep, false) setMetaDefaults(ep) val nm = setupConnection(ep, mcServer) // Run the real join pipeline playerList.javaClass.getMethod("a", nms("NetworkManager"), nms("EntityPlayer")) .apply { isAccessible = true } .invoke(playerList, nm, ep) // Clean up the duplicate UUID warning: ensure we don't re-add if PlayerList already did runCatching { val playersField = playerList.javaClass.getDeclaredField("players") playersField.isAccessible = true val list = playersField.get(playerList) as MutableList if (!list.contains(ep)) list.add(ep) } // Ensure CraftServer maps see the player (for Bukkit.getPlayer) updateCraftMaps(craftServer, bukkitPlayer!!) // Force entity into world lists (safety) runCatching { worldServer.javaClass.getMethod("addEntity", nms("Entity")).invoke(worldServer, ep) } // Ensure chunk tracking in case join path skipped it runCatching { val pcm = worldServer.javaClass.getMethod("getPlayerChunkMap").invoke(worldServer) pcm.javaClass.methods.firstOrNull { it.name == "addPlayer" && it.parameterCount == 1 }?.invoke(pcm, ep) pcm.javaClass.methods.firstOrNull { it.name == "movePlayer" && it.parameterCount == 1 }?.invoke(pcm, ep) } // Broadcast spawn packets (ADD_PLAYER + NamedEntitySpawn) to online players runCatching { val packetInfoClass = nms("PacketPlayOutPlayerInfo") val enumInfo = packetInfoClass.declaredClasses.first { it.simpleName.contains("EnumPlayerInfoAction") } val addPlayer = enumInfo.getField("ADD_PLAYER").get(null) val epArray = java.lang.reflect.Array.newInstance(nms("EntityPlayer"), 1).apply { java.lang.reflect.Array.set(this, 0, ep) } val infoCtor = packetInfoClass.getConstructor(enumInfo, epArray.javaClass) val infoPacket = infoCtor.newInstance(addPlayer, epArray) val spawnPacketClass = nms("PacketPlayOutNamedEntitySpawn") val spawnCtor = spawnPacketClass.getConstructor(nms("EntityHuman")) val spawnPacket = spawnCtor.newInstance(ep) val attrPacketClass = nms("PacketPlayOutUpdateAttributes") val attrCtor = attrPacketClass.getConstructor(nms("EntityLiving"), java.util.Collection::class.java) val attrMethod = ep.javaClass.methods.firstOrNull { it.name == "getAttributeInstance" } val attributes = java.util.ArrayList() // health and attack damage attributes if available runCatching { val generic = Class.forName("org.bukkit.attribute.Attribute") val healthEnum = generic.getField("GENERIC_MAX_HEALTH").get(null) val dmgEnum = generic.getField("GENERIC_ATTACK_DAMAGE").get(null) val attrBase = ep.javaClass.methods.firstOrNull { it.name == "getAttributeInstance" && it.parameterTypes.size == 1 } val healthInst = attrBase?.invoke(ep, nms("GenericAttributes").getField("MAX_HEALTH").get(null)) val dmgInst = attrBase?.invoke(ep, nms("GenericAttributes").getField("ATTACK_DAMAGE").get(null)) if (healthInst != null) attributes.add(healthInst) if (dmgInst != null) attributes.add(dmgInst) } val attrPacket = runCatching { attrCtor.newInstance(ep, attributes) }.getOrNull() val heldSlotClass = nms("PacketPlayOutHeldItemSlot") val heldSlotPacket = runCatching { heldSlotClass.getConstructor(Int::class.javaPrimitiveType).newInstance(0) }.getOrNull() val windowItemsClass = nms("PacketPlayOutWindowItems") val inventory = ep.javaClass.getField("inventory").get(ep) val getContents = inventory.javaClass.methods.firstOrNull { it.name == "getContents" && it.parameterCount == 0 } val contents = runCatching { getContents?.invoke(inventory) as? Array }.getOrNull() val windowPacket = runCatching { windowItemsClass.constructors.first().newInstance(0, listOf(*contents ?: emptyArray())) }.getOrNull() val healthClass = nms("PacketPlayOutUpdateHealth") val healthPacket = runCatching { val health = ep.javaClass.getMethod("getHealth").invoke(ep) as Float val food = ep.javaClass.getMethod("getFoodData").invoke(ep) val foodLevel = food.javaClass.getMethod("getFoodLevel").invoke(food) as Int val saturation = food.javaClass.getMethod("getSaturationLevel").invoke(food) as Float healthClass.getConstructor(Float::class.javaPrimitiveType, Int::class.javaPrimitiveType, Float::class.javaPrimitiveType) .newInstance(health, foodLevel, saturation) }.getOrNull() val metaClass = nms("PacketPlayOutEntityMetadata") val metaCtor = metaClass.getConstructor(Int::class.javaPrimitiveType, nms("DataWatcher"), Boolean::class.javaPrimitiveType) val dataWatcher = ep.javaClass.getMethod("getDataWatcher").invoke(ep) val metaPacket = metaCtor.newInstance(ep.javaClass.getMethod("getId").invoke(ep) as Int, dataWatcher, true) val animClass = nms("PacketPlayOutAnimation") val swingPacket = runCatching { animClass.getConstructor(nms("Entity"), Int::class.javaPrimitiveType).newInstance(ep, 0) }.getOrNull() Bukkit.getOnlinePlayers().forEach { viewer -> val handle = viewer.javaClass.getMethod("getHandle").invoke(viewer) val conn = handle.javaClass.getField("playerConnection").get(handle) val send = conn.javaClass.methods.first { it.name == "sendPacket" && it.parameterTypes.size == 1 } send.invoke(conn, infoPacket) send.invoke(conn, spawnPacket) if (attrPacket != null) send.invoke(conn, attrPacket) if (heldSlotPacket != null) send.invoke(conn, heldSlotPacket) if (windowPacket != null) send.invoke(conn, windowPacket) if (healthPacket != null) send.invoke(conn, healthPacket) send.invoke(conn, metaPacket) if (swingPacket != null) send.invoke(conn, swingPacket) } } // Tick task to keep status/effects progressing Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, Runnable { runCatching { // playerTick is "m" in 1.9; fall back to "n" if obf differs val tick = ep.javaClass.methods.firstOrNull { it.name == "m" && it.parameterCount == 0 } ?: ep.javaClass.methods.firstOrNull { it.name == "n" && it.parameterCount == 0 } ?: ep.javaClass.methods.firstOrNull { it.name == "playerTick" && it.parameterCount == 0 } tick?.invoke(ep) // Keep entity alive/valid flags cleared so Bukkit reports the player as valid runCatching { val deadField = ep.javaClass.superclass.getDeclaredField("dead") deadField.isAccessible = true deadField.setBoolean(ep, false) } runCatching { val craftEntity = Class.forName("org.bukkit.craftbukkit.$cbVersion.entity.CraftEntity") val validField = craftEntity.getDeclaredField("valid") validField.isAccessible = true validField.setBoolean(bukkitPlayer, true) } } // keep chunk tracking fresh runCatching { val worldServer = ep.javaClass.getMethod("getWorld").invoke(ep) val pcm = worldServer.javaClass.getMethod("getPlayerChunkMap").invoke(worldServer) pcm.javaClass.methods.firstOrNull { it.name == "movePlayer" && it.parameterCount == 1 }?.invoke(pcm, ep) } // Apply queued effects/fire ticks runCatching { // Force entity base tick for fire/water checks ep.javaClass.methods.firstOrNull { it.name == "ae" && it.parameterCount == 0 } // baseTick in 1.9 obf ?.invoke(ep) } // Ensure water extinguishes burning for fake players on legacy runCatching { val bp = bukkitPlayer if (bp != null && bp.fireTicks > 0 && bp.location.block.isLiquid) { bp.fireTicks = 0 } } }, 1L, 1L) } fun removePlayer() { val ep = entityPlayer ?: return val bp = bukkitPlayer ?: return val craftServer = craft("CraftServer").cast(Bukkit.getServer()) val mcServer = craftServer.javaClass.getMethod("getServer").invoke(craftServer) val playerList = mcServer.javaClass.getMethod("getPlayerList").invoke(mcServer) bp.kickPlayer("§e$name left the game") runCatching { playerList.javaClass.getMethod("disconnect", nms("EntityPlayer")).invoke(playerList, ep) }.onFailure { runCatching { playerList.javaClass.getMethod("remove", nms("EntityPlayer")).invoke(playerList, ep) } } runCatching { val pcm = getPlayerChunkMap(ep) pcm?.javaClass?.methods?.firstOrNull { it.name == "removePlayer" && it.parameterCount == 1 }?.invoke(pcm, ep) } } fun getConnection(serverPlayer: Any): Any { val field = serverPlayer.javaClass.getField("playerConnection") return field.get(serverPlayer) } private fun createEntityPlayer(mcServer: Any, worldServer: Any): Any { val epClass = nms("EntityPlayer") val pimClass = nms("PlayerInteractManager") // PlayerInteractManager(World | WorldServer) val pimCtor = pimClass.constructors.firstOrNull { ctor -> ctor.parameterTypes.size == 1 && ctor.parameterTypes[0].isAssignableFrom(worldServer.javaClass) } ?: pimClass.constructors.first() val pim = pimCtor.newInstance(worldServer) val gp = GameProfile(uuid, name) val ctor = epClass.constructors.firstOrNull { ctor -> val p = ctor.parameterTypes p.size == 4 && p[0].isAssignableFrom(mcServer.javaClass) && p[1].isAssignableFrom(worldServer.javaClass) && p[2].isAssignableFrom(GameProfile::class.java) && p[3].isAssignableFrom(pimClass) } ?: epClass.constructors.first() return ctor.newInstance(mcServer, worldServer, gp, pim) } private fun setupConnection(ep: Any, mcServer: Any): Any { val nmClass = nms("NetworkManager") val dirClass = nms("EnumProtocolDirection") val clientbound = dirClass.getField("CLIENTBOUND").get(null) val nm = nmClass.getConstructor(dirClass).newInstance(clientbound) // Dummy channel with predictable address val remote = java.net.InetSocketAddress("127.0.0.1", 25565) val channel = EmbeddedChannel(ChannelInboundHandlerAdapter()) val pipeline = channel.pipeline() if (pipeline.get("decoder") == null) { pipeline.addLast("decoder", ChannelInboundHandlerAdapter()) } if (pipeline.get("encoder") == null) { pipeline.addLast("encoder", ChannelOutboundHandlerAdapter()) } nmClass.getField("channel").set(nm, channel) runCatching { nmClass.getField("socketAddress").set(nm, remote) } val pcClass = nms("PlayerConnection") val pc = pcClass.getConstructor(nms("MinecraftServer"), nmClass, nms("EntityPlayer")) .newInstance(mcServer, nm, ep) ep.javaClass.getField("playerConnection").set(ep, pc) runCatching { val setListener = nmClass.methods.firstOrNull { it.name == "setPacketListener" && it.parameterCount == 1 } setListener?.invoke(nm, pc) } runCatching { val enumProtocol = nms("EnumProtocol") val play = enumProtocol.getField("PLAY").get(null) nmClass.methods.firstOrNull { it.name == "a" && it.parameterTypes.singleOrNull() == enumProtocol } ?.invoke(nm, play) } runCatching { nmClass.fields.firstOrNull { it.name == "isPending" }?.setBoolean(nm, false) } return nm } private fun setPosition(ep: Any, loc: Location) { ep.javaClass.getMethod( "setPositionRotation", Double::class.javaPrimitiveType, Double::class.javaPrimitiveType, Double::class.javaPrimitiveType, Float::class.javaPrimitiveType, Float::class.javaPrimitiveType ).invoke(ep, loc.x, loc.y, loc.z, loc.yaw, loc.pitch) } private fun setGameMode(ep: Any) { val gmName = when (Bukkit.getDefaultGameMode()) { GameMode.CREATIVE -> "CREATIVE" GameMode.ADVENTURE -> "ADVENTURE" GameMode.SPECTATOR -> "SPECTATOR" else -> "SURVIVAL" } val enumGMClass = nms("WorldSettings\$EnumGamemode") val enumGM = enumGMClass.getField(gmName).get(null) val pim = ep.javaClass.getField("playerInteractManager").get(ep) // prefer setGameMode / b(EnumGamemode) val method = pim.javaClass.methods.firstOrNull { it.name in listOf("setGameMode", "b") && it.parameterTypes.size == 1 } ?: pim.javaClass.getMethod("b", enumGMClass) method.isAccessible = true method.invoke(pim, enumGM) } private fun setVulnerability(ep: Any, invulnerable: Boolean) { runCatching { ep.javaClass.getField("invulnerableTicks").setInt(ep, if (invulnerable) 20 else 0) } runCatching { ep.javaClass.getField("noDamageTicks").setInt(ep, if (invulnerable) 20 else 0) } runCatching { val abilities = ep.javaClass.getField("abilities").get(ep) val flags = mapOf( "isInvulnerable" to invulnerable, "isFlying" to false, "mayfly" to false, "canInstantlyBuild" to false ) flags.forEach { (k, v) -> runCatching { abilities.javaClass.getField(k).setBoolean(abilities, v) } } ep.javaClass.getMethod("updateAbilities").invoke(ep) } } private fun setMetaDefaults(ep: Any) { runCatching { val dw = ep.javaClass.getMethod("getDataWatcher").invoke(ep) val serializerRegistry = nms("DataWatcherRegistry") val byteSerializer = serializerRegistry.getField("a").get(null) val floatSerializer = serializerRegistry.getField("c").get(null) val dwoClass = nms("DataWatcherObject") val dwoCtor = dwoClass.getConstructor(Int::class.javaPrimitiveType, nms("DataWatcherSerializer")) val set = dw.javaClass.methods.first { it.name == "set" && it.parameterTypes.size == 2 } // flag byte (index 0) -> 0 val flag0 = dwoCtor.newInstance(0, byteSerializer) set.invoke(dw, flag0, 0.toByte()) // health (index 6) -> 20f val healthObj = dwoCtor.newInstance(6, floatSerializer) set.invoke(dw, healthObj, 20.0f) } } private fun firePreLogin() { val addr = InetAddress.getLoopbackAddress() val async = AsyncPlayerPreLoginEvent(name, addr, uuid) val sync = PlayerPreLoginEvent(name, addr, uuid) Thread { Bukkit.getPluginManager().callEvent(async) }.start() Bukkit.getPluginManager().callEvent(sync) } private fun getChunkProvider(ep: Any): Any? = runCatching { val worldServer = ep.javaClass.getMethod("getWorld").invoke(ep) worldServer.javaClass.getMethod("getChunkProviderServer").invoke(worldServer) }.getOrNull() private fun getPlayerChunkMap(ep: Any): Any? = runCatching { val worldServer = ep.javaClass.getMethod("getWorld").invoke(ep) worldServer.javaClass.getMethod("getPlayerChunkMap").invoke(worldServer) }.getOrNull() private fun updateCraftMaps(craftServer: Any, player: Player) { runCatching { val playersField = craftServer.javaClass.getDeclaredField("players") playersField.isAccessible = true val map = playersField.get(craftServer) as MutableMap map[player.name.lowercase(Locale.getDefault())] = player } runCatching { val uuidField = craftServer.javaClass.getDeclaredField("playersByUUID") uuidField.isAccessible = true val map = uuidField.get(craftServer) as MutableMap map[player.uniqueId] = player } } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/ModesetRulesIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.booleans.shouldBeFalse import io.kotest.matchers.booleans.shouldBeTrue import io.kotest.assertions.throwables.shouldThrow import kernitus.plugin.OldCombatMechanics.module.ModuleDisableOffHand import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.configuration.ConfigurationSection import org.bukkit.entity.Player import org.bukkit.plugin.java.JavaPlugin import java.util.Locale import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class ModesetRulesIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleDisableOffHand not registered") val internalModules = setOf( "modeset-listener", "attack-cooldown-tracker", "entity-damage-listener" ) val optionalModules = setOf( "disable-attack-sounds", "disable-sword-sweep-particles" ) lateinit var player: Player lateinit var fakePlayer: FakePlayer extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun setModeset(player: Player, modeset: String) { val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) setPlayerData(player.uniqueId, playerData) } fun snapshotSection(path: String): Any? { val section = ocm.config.getConfigurationSection(path) return section?.getValues(false) ?: ocm.config.get(path) } fun restoreSection(path: String, value: Any?) { ocm.config.set(path, null) when (value) { null -> Unit is Map<*, *> -> { @Suppress("UNCHECKED_CAST") ocm.config.createSection(path, value as Map) } else -> ocm.config.set(path, value) } } fun applyConfig( always: List, disabled: List, modesets: Map>, worldModesets: List ) { ocm.config.set("always_enabled_modules", always) ocm.config.set("disabled_modules", disabled) ocm.config.set("modesets", null) ocm.config.createSection("modesets", modesets) ocm.config.set("worlds.world", worldModesets) ocm.saveConfig() Config.reload() } fun completeAlways( always: List, disabled: List, modesets: Map> ): List { val assigned = HashSet() always.forEach { assigned.add(it.lowercase(Locale.ROOT)) } disabled.forEach { assigned.add(it.lowercase(Locale.ROOT)) } modesets.values.flatten().forEach { assigned.add(it.lowercase(Locale.ROOT)) } val filled = LinkedHashSet() filled.addAll(always) ModuleLoader.getModules() .map { it.configName.lowercase(Locale.ROOT) } .sorted() .filterNot { assigned.contains(it) } .filterNot { internalModules.contains(it) } .forEach { filled.add(it) } optionalModules .filterNot { assigned.contains(it) } .forEach { filled.add(it) } return filled.toList() } suspend fun withConfig(block: suspend () -> Unit) { val originalAlways = ocm.config.get("always_enabled_modules") val originalDisabled = ocm.config.get("disabled_modules") val originalModesets = snapshotSection("modesets") val originalWorlds = snapshotSection("worlds") try { block() } finally { runSync { ocm.config.set("always_enabled_modules", originalAlways) ocm.config.set("disabled_modules", originalDisabled) restoreSection("modesets", originalModesets) restoreSection("worlds", originalWorlds) ocm.saveConfig() Config.reload() } } } beforeSpec { runSync { val world = checkNotNull(Bukkit.getServer().getWorld("world")) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(Location(world, 0.0, 100.0, 0.0)) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) } } afterSpec { runSync { fakePlayer.removePlayer() } } test("always-enabled modules apply regardless of modeset") { withConfig { runSync { applyConfig( always = completeAlways( always = listOf("disable-offhand"), disabled = emptyList(), modesets = mapOf( "old" to listOf("old-golden-apples"), "new" to listOf("old-potion-effects") ) ), disabled = emptyList(), modesets = mapOf( "old" to listOf("old-golden-apples"), "new" to listOf("old-potion-effects") ), worldModesets = listOf("old", "new") ) setModeset(player, "old") module.isEnabled(player).shouldBeTrue() setModeset(player, "new") module.isEnabled(player).shouldBeTrue() } } } test("disabled modules never apply") { withConfig { runSync { applyConfig( always = completeAlways( always = emptyList(), disabled = listOf("disable-offhand"), modesets = mapOf( "old" to listOf("old-golden-apples"), "new" to listOf("old-potion-effects") ) ), disabled = listOf("disable-offhand"), modesets = mapOf( "old" to listOf("old-golden-apples"), "new" to listOf("old-potion-effects") ), worldModesets = listOf("old", "new") ) setModeset(player, "old") module.isEnabled(player).shouldBeFalse() setModeset(player, "new") module.isEnabled(player).shouldBeFalse() } } } test("modeset membership controls module activation") { withConfig { runSync { applyConfig( always = completeAlways( always = emptyList(), disabled = emptyList(), modesets = mapOf( "old" to listOf("disable-offhand"), "new" to listOf("old-potion-effects") ) ), disabled = emptyList(), modesets = mapOf( "old" to listOf("disable-offhand"), "new" to listOf("old-potion-effects") ), worldModesets = listOf("old", "new") ) setModeset(player, "old") module.isEnabled(player).shouldBeTrue() setModeset(player, "new") module.isEnabled(player).shouldBeFalse() } } } test("modules in disabled and another list fail reload") { withConfig { runSync { shouldThrow { applyConfig( always = completeAlways( always = listOf("disable-offhand"), disabled = listOf("disable-offhand"), modesets = mapOf( "old" to listOf("old-potion-effects"), "new" to listOf("old-golden-apples") ) ), disabled = listOf("disable-offhand"), modesets = mapOf( "old" to listOf("old-potion-effects"), "new" to listOf("old-golden-apples") ), worldModesets = listOf("old", "new") ) } } } } test("modules missing from all lists fail reload") { withConfig { runSync { val moduleNames = (ModuleLoader.getModules() .map { it.configName } .filterNot { internalModules.contains(it) } + optionalModules) .distinct() .sorted() val missing = moduleNames.firstOrNull() ?: error("No modules registered") val always = moduleNames.filterNot { it == missing } shouldThrow { applyConfig( always = always, disabled = emptyList(), modesets = mapOf("old" to emptyList()), worldModesets = listOf("old") ) } } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OCMTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import org.bukkit.inventory.ItemStack class OCMTest( val weapon: ItemStack, val armour: Array, val attackDelay: Long, val message: String, val preparations: Runnable ) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OCMTestMain.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage import org.bukkit.Bukkit import org.bukkit.plugin.java.JavaPlugin import java.lang.reflect.InvocationTargetException import java.util.logging.Level class OCMTestMain : JavaPlugin() { override fun onEnable() { logger.info("Enabled OCMTest plugin") // Initialise player data storage val ocm = Bukkit.getPluginManager().getPlugin("OldCombatMechanics") as OCMMain PlayerStorage.initialise(ocm) val javaVersion = detectJavaVersion() logger.info("Detected Java $javaVersion for integration tests") System.setProperty("kotest.framework.classpath.scanning.autoscan.disable", "true") runKotest() } private fun runKotest() { try { val runnerClass = Class.forName("kernitus.plugin.OldCombatMechanics.KotestRunner") val runMethod = runnerClass.getMethod("run", JavaPlugin::class.java) runMethod.invoke(null, this) } catch (e: InvocationTargetException) { logger.log(Level.SEVERE, "Failed to launch Kotest runner.", e.targetException ?: e) TestResultWriter.writeAndShutdown(this, false) } catch (e: Throwable) { logger.log(Level.SEVERE, "Failed to launch Kotest runner.", e) TestResultWriter.writeAndShutdown(this, false) } } private fun detectJavaVersion(): Int { val version = System.getProperty("java.specification.version") ?: return 0 return if (version.startsWith("1.")) { version.substringAfter("1.").toIntOrNull() ?: 0 } else { version.toIntOrNull() ?: 0 } } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OldArmourDurabilityIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleOldArmourDurability import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.player.PlayerItemDamageEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class OldArmourDurabilityIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleOldArmourDurability not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val reduction = ocm.config.getInt("old-armour-durability.reduction") try { block() } finally { ocm.config.set("old-armour-durability.reduction", reduction) module.reload() ModuleLoader.toggleModules() } } fun setModeset(modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) } fun createItemDamageEvent(item: ItemStack, damage: Int): PlayerItemDamageEvent { val ctor = PlayerItemDamageEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 4 && Player::class.java.isAssignableFrom(params[0]) && ItemStack::class.java.isAssignableFrom(params[1]) && params[2] == Int::class.javaPrimitiveType && params[3] == Int::class.javaPrimitiveType } return if (ctor != null) { ctor.newInstance(player, item, damage, damage) as PlayerItemDamageEvent } else { PlayerItemDamageEvent(player, item, damage) } } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getServer().getWorld("world") val location = Location(world, 0.0, 100.0, 0.0) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) player.isOp = true setModeset("old") } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } setModeset("old") module.reload() } } context("Armour durability reduction") { test("worn armour takes reduced durability") { withConfig { ocm.config.set("old-armour-durability.reduction", 2) module.reload() val helmet = ItemStack(Material.DIAMOND_HELMET) player.inventory.helmet = helmet val event = createItemDamageEvent(helmet, 5) Bukkit.getPluginManager().callEvent(event) event.damage shouldBe 2 } } test("non-armour items are ignored") { withConfig { ocm.config.set("old-armour-durability.reduction", 2) module.reload() val sword = ItemStack(Material.DIAMOND_SWORD) player.inventory.setItemInMainHand(sword) val event = createItemDamageEvent(sword, 5) Bukkit.getPluginManager().callEvent(event) event.damage shouldBe 5 } } test("elytra is ignored") { withConfig { ocm.config.set("old-armour-durability.reduction", 2) module.reload() val elytra = ItemStack(Material.ELYTRA) player.inventory.chestplate = elytra val event = createItemDamageEvent(elytra, 5) Bukkit.getPluginManager().callEvent(event) event.damage shouldBe 5 } } } context("Explosion handling") { test("explosion damage bypasses durability reduction") { withConfig { ocm.config.set("old-armour-durability.reduction", 2) module.reload() val helmet = ItemStack(Material.DIAMOND_HELMET) player.inventory.helmet = helmet val explosion = EntityDamageEvent(player, EntityDamageEvent.DamageCause.BLOCK_EXPLOSION, 6.0) Bukkit.getPluginManager().callEvent(explosion) val event = createItemDamageEvent(helmet, 5) Bukkit.getPluginManager().callEvent(event) event.damage shouldBe 5 } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OldCriticalHitsIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XMaterial import io.kotest.common.ExperimentalKotest import io.kotest.assertions.withClue import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleOldCriticalHits import kernitus.plugin.OldCombatMechanics.module.ModuleOldToolDamage import kernitus.plugin.OldCombatMechanics.utilities.damage.DamageUtils import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.attribute.AttributeModifier import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.util.Vector import java.util.concurrent.Callable import java.util.UUID import kotlin.math.abs @OptIn(ExperimentalKotest::class) class OldCriticalHitsIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val criticalModule = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleOldCriticalHits not registered") val toolDamageModule = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleOldToolDamage not registered") lateinit var attacker: Player lateinit var fakeAttacker: FakePlayer extensions(MainThreadDispatcherExtension(testPlugin)) val isLegacy = !Reflector.versionIsNewerOrEqualTo(1, 13, 0) val legacySpeedModifierId = UUID.fromString("c1f6010f-4d2e-4b2e-9a2f-3f0d0f1b2e3c") fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun setOnGround(player: Player, onGround: Boolean) { val handle = player.javaClass.getMethod("getHandle").invoke(player) val field = generateSequence(handle.javaClass) { it.superclass } .mapNotNull { klass -> runCatching { klass.getDeclaredField("onGround") }.getOrNull() } .firstOrNull() field?.let { it.isAccessible = true it.setBoolean(handle, onGround) return } val setOnGroundMethod = generateSequence(handle.javaClass) { it.superclass } .mapNotNull { klass -> runCatching { klass.getDeclaredMethod("setOnGround", Boolean::class.javaPrimitiveType) }.getOrNull() } .firstOrNull() setOnGroundMethod?.let { it.isAccessible = true it.invoke(handle, onGround) } } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(player: Player, item: ItemStack) { if (isLegacy) { val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() val speedAttribute = attackSpeedAttribute?.let { player.getAttribute(it) } speedAttribute ?.modifiers ?.filter { it.uniqueId == legacySpeedModifierId } ?.forEach { speedAttribute.removeModifier(it) } val speedModifier = createAttributeModifier( name = "ocm-legacy-speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND, uuid = legacySpeedModifierId ) speedAttribute?.addModifier(speedModifier) return } val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) val expectedAmounts = modifiers .filter { it.operation == AttributeModifier.Operation.ADD_NUMBER } .map { it.amount } val knownWeaponAmounts = NewWeaponDamage.values() .map { it.damage.toDouble() - 1.0 } .filter { it > 0.0 } .toSet() fun matchesAmount(first: Double, second: Double): Boolean = abs(first - second) <= 0.0001 val existingModifiers = attackAttribute.modifiers.toList() existingModifiers .filter { it.operation == AttributeModifier.Operation.ADD_NUMBER && it.amount > 0.0 } .filter { modifier -> knownWeaponAmounts.any { matchesAmount(it, modifier.amount) } && expectedAmounts.none { expected -> matchesAmount(expected, modifier.amount) } } .forEach { attackAttribute.removeModifier(it) } modifiers.forEach { modifier -> val alreadyApplied = attackAttribute.modifiers.any { it.operation == modifier.operation && matchesAmount(it.amount, modifier.amount) } if (!alreadyApplied) { attackAttribute.addModifier(modifier) } } } fun equip(player: Player, item: ItemStack) { if (isLegacy) { // On legacy versions, avoid mutating item meta; directly adjust player attributes instead. val meta = item.itemMeta if (meta != null) { runCatching { XAttribute.ATTACK_DAMAGE.get()?.let { meta.removeAttributeModifier(it) } XAttribute.ATTACK_SPEED.get()?.let { meta.removeAttributeModifier(it) } } runCatching { meta.removeAttributeModifier(EquipmentSlot.HAND) } runCatching { meta.removeAttributeModifier(EquipmentSlot.OFF_HAND) } item.itemMeta = meta } val useDamageAttribute = !Reflector.versionIsNewerOrEqualTo(1, 12, 0) if (useDamageAttribute) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() val damageAttribute = attackDamageAttribute?.let { player.getAttribute(it) } val configuredDamage = WeaponDamages.getDamage(item.type).toDouble().takeIf { it > 0 } ?: (NewWeaponDamage.getDamageOrNull(item.type) ?: 1.0f).toDouble() damageAttribute?.baseValue = configuredDamage } player.inventory.setItemInMainHand(item) applyAttackDamageModifiers(player, item) player.updateInventory() return } prepareWeapon(item) player.inventory.setItemInMainHand(item) applyAttackDamageModifiers(player, item) player.updateInventory() } fun spawnVictim(location: Location): LivingEntity { val world = location.world ?: error("World missing for victim spawn") return world.spawn(location, org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 0 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } suspend fun hitAndCaptureDamage( weapon: ItemStack, critical: Boolean ): Double { val events = mutableListOf() val ocmEvents = mutableListOf() lateinit var victim: LivingEntity val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == attacker.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) testPlugin.logger.info( "Critical hit debug: weapon=${attacker.inventory.itemInMainHand.type} " + "critical=$critical sprinting=${attacker.isSprinting} " + "fallDistance=${attacker.fallDistance} onGround=${attacker.isOnGround} " + "damage=${event.damage} finalDamage=${event.finalDamage}" ) } } @EventHandler fun onOcm(event: OCMEntityDamageByEntityEvent) { if (event.damager.uniqueId == attacker.uniqueId && event.damagee.uniqueId == victim.uniqueId ) { ocmEvents.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val victimLocation = Location(world, 1.2, 100.0, 0.0) victim = spawnVictim(victimLocation) Bukkit.getPluginManager().registerEvents(listener, testPlugin) equip(attacker, weapon) } delayTicks(1) if (isLegacy) { // Vanilla 1.12 applies attack cooldown scaling before the Bukkit damage event fires. // Give the fake player a short warmup so the baseline (non-critical) hit is not under-scaled. delayTicks(6) } val base = Location(attacker.world, 0.0, 100.0, 0.0) runSync { attacker.teleport(base) attacker.velocity = Vector(0.0, 0.0, 0.0) attacker.isSprinting = false attacker.fallDistance = 0f attacker.updateInventory() } if (critical) { // Give the server one tick to recognise the falling state, then re-apply immediately before the swing // so it does not get cleared by ticking (varies by version / fake player internals). runSync { attacker.isSprinting = true attacker.teleport(attacker.location.add(0.0, 1.0, 0.0)) attacker.velocity = Vector(0.0, -0.1, 0.0) attacker.fallDistance = 2f setOnGround(attacker, false) } delayTicks(1) runSync { attacker.isSprinting = true attacker.velocity = Vector(0.0, -0.1, 0.0) attacker.fallDistance = 2f setOnGround(attacker, false) if (!DamageUtils.isCriticalHit1_8(attacker)) { attacker.fallDistance = 3f setOnGround(attacker, false) } val loc = attacker.location val dir = victim.location.toVector().subtract(loc.toVector()).normalize() loc.direction = dir attacker.teleport(loc) testPlugin.logger.info( "Critical pre-attack: fallDistance=${attacker.fallDistance} onGround=${attacker.isOnGround}" ) attacker.updateInventory() attackCompat(attacker, victim) } } else { runSync { attacker.isSprinting = false attacker.fallDistance = 0f attacker.velocity = Vector(0.0, 0.0, 0.0) val loc = attacker.location val dir = victim.location.toVector().subtract(loc.toVector()).normalize() loc.direction = dir attacker.teleport(loc) testPlugin.logger.info( "Normal pre-attack: fallDistance=${attacker.fallDistance} onGround=${attacker.isOnGround}" ) attacker.updateInventory() attackCompat(attacker, victim) } } delayTicks(4) events.firstOrNull()?.damage?.let { return it } if (critical) { val ocmEvent = ocmEvents.lastOrNull() if (ocmEvent != null && !ocmEvent.was1_8Crit()) { testPlugin.logger.info( "Critical path but was1_8Crit=false; fallDistance=${attacker.fallDistance} " + "onGround=${attacker.isOnGround}" ) } } if (isLegacy) { // As a last resort on legacy, drive damage via Bukkit API to ensure EDBE fires. runSync { val base = WeaponDamages.getDamage(weapon.type).takeIf { it > 0 } ?: 1.0 victim.damage(base, attacker) } delayTicks(4) events.firstOrNull()?.damage?.let { return it } val healthDelta = (victim.maxHealth - victim.health).toDouble() if (healthDelta > 0.0) return healthDelta } error("Expected a damage event for critical=$critical") } finally { HandlerList.unregisterAll(listener) runSync { victim.remove() } } } suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val critEnabled = ocm.config.getBoolean("old-critical-hits.enabled") val critMultiplier = ocm.config.getDouble("old-critical-hits.multiplier") val critAllowSprinting = ocm.config.getBoolean("old-critical-hits.allow-sprinting") val damagesSection = ocm.config.getConfigurationSection("old-tool-damage.damages") val damagesSnapshot = damagesSection?.getKeys(false)?.associateWith { damagesSection.get(it) } ?: emptyMap() fun reloadDamageModules() { WeaponDamages.initialise(ocm) criticalModule.reload() toolDamageModule.reload() ModuleLoader.toggleModules() } try { block() } finally { ocm.config.set("old-critical-hits.enabled", critEnabled) ocm.config.set("old-critical-hits.multiplier", critMultiplier) ocm.config.set("old-critical-hits.allow-sprinting", critAllowSprinting) damagesSnapshot.forEach { (key, value) -> ocm.config.set("old-tool-damage.damages.$key", value) } reloadDamageModules() } } beforeSpec { runSync { val world = checkNotNull(Bukkit.getWorld("world")) val location = Location(world, 0.0, 100.0, 0.0) fakeAttacker = FakePlayer(testPlugin) fakeAttacker.spawn(location) attacker = checkNotNull(Bukkit.getPlayer(fakeAttacker.uuid)) attacker.gameMode = GameMode.SURVIVAL attacker.isInvulnerable = false attacker.inventory.clear() attacker.activePotionEffects.forEach { attacker.removePotionEffect(it.type) } attacker.isOp = true val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(attacker.uniqueId) playerData.setModesetForWorld(attacker.world.uid, "old") kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(attacker.uniqueId, playerData) } } afterSpec { runSync { fakeAttacker.removePlayer() } } test("critical hit multiplier applies to customised tool damage") { withConfig { ocm.config.set("old-critical-hits.enabled", true) ocm.config.set("old-critical-hits.multiplier", 1.5) ocm.config.set("old-critical-hits.allow-sprinting", true) ocm.config.set("old-tool-damage.damages.STONE_SWORD", 10) WeaponDamages.initialise(ocm) criticalModule.reload() toolDamageModule.reload() ModuleLoader.toggleModules() val stoneSword = XMaterial.STONE_SWORD.parseItem() ?: error("STONE_SWORD material not available") val normalDamage = hitAndCaptureDamage(stoneSword, critical = false) val criticalDamage = hitAndCaptureDamage(stoneSword, critical = true) withClue("normal=$normalDamage critical=$criticalDamage") { (criticalDamage / normalDamage) shouldBe (1.5 plusOrMinus 0.05) } } } test("critical hit multiplier applies when tool damage matches vanilla values") { withConfig { ocm.config.set("old-critical-hits.enabled", true) ocm.config.set("old-critical-hits.multiplier", 1.5) ocm.config.set("old-critical-hits.allow-sprinting", true) ocm.config.set("old-tool-damage.damages.IRON_SWORD", 6) WeaponDamages.initialise(ocm) criticalModule.reload() toolDamageModule.reload() ModuleLoader.toggleModules() val ironSword = XMaterial.IRON_SWORD.parseItem() ?: error("IRON_SWORD material not available") val normalDamage = hitAndCaptureDamage(ironSword, critical = false) val criticalDamage = hitAndCaptureDamage(ironSword, critical = true) withClue("normal=$normalDamage critical=$criticalDamage") { (criticalDamage / normalDamage) shouldBe (1.5 plusOrMinus 0.05) } } } test("critical hit multiplier applies to config damage for iron axe") { withConfig { ocm.config.set("old-critical-hits.enabled", true) ocm.config.set("old-critical-hits.multiplier", 1.5) ocm.config.set("old-critical-hits.allow-sprinting", true) ocm.config.set("old-tool-damage.damages.IRON_AXE", 6) WeaponDamages.initialise(ocm) criticalModule.reload() toolDamageModule.reload() ModuleLoader.toggleModules() val ironAxe = XMaterial.IRON_AXE.parseItem() ?: error("IRON_AXE material not available") val normalDamage = hitAndCaptureDamage(ironAxe, critical = false) val criticalDamage = hitAndCaptureDamage(ironAxe, critical = true) testPlugin.logger.info("Crit debug (cfg=6): normal=$normalDamage critical=$criticalDamage") withClue("normal=$normalDamage critical=$criticalDamage") { (criticalDamage / normalDamage) shouldBe (1.5 plusOrMinus 0.05) } } } test("critical hit multiplies configured iron axe damage") { withConfig { ocm.config.set("old-critical-hits.enabled", true) ocm.config.set("old-critical-hits.multiplier", 1.25) ocm.config.set("old-critical-hits.allow-sprinting", true) ocm.config.set("old-tool-damage.damages.IRON_AXE", 4.5) WeaponDamages.initialise(ocm) criticalModule.reload() toolDamageModule.reload() ModuleLoader.toggleModules() val ironAxe = XMaterial.IRON_AXE.parseItem() ?: error("IRON_AXE material not available") val normalDamage = hitAndCaptureDamage(ironAxe, critical = false) val criticalDamage = hitAndCaptureDamage(ironAxe, critical = true) testPlugin.logger.info("Crit debug (cfg=4.5): normal=$normalDamage critical=$criticalDamage") withClue("normal=$normalDamage critical=$criticalDamage") { normalDamage shouldBe (4.5 plusOrMinus 0.05) criticalDamage shouldBe (5.625 plusOrMinus 0.05) } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OldPotionEffectsIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.booleans.shouldBeFalse import io.kotest.matchers.booleans.shouldBeTrue import io.kotest.matchers.collections.shouldHaveSize import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.ints.shouldBeExactly import io.kotest.matchers.ints.shouldBeLessThanOrEqual import io.kotest.matchers.shouldBe import io.kotest.matchers.shouldNotBe import kernitus.plugin.OldCombatMechanics.module.ModuleOldPotionEffects import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent import com.cryptomorin.xseries.XAttribute import com.cryptomorin.xseries.XMaterial import com.cryptomorin.xseries.XPotion import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.AttributeModifier import org.bukkit.block.BlockFace import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.block.Action import org.bukkit.event.block.BlockDispenseEvent import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.EventPriority import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.event.player.PlayerItemConsumeEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.PotionMeta import org.bukkit.plugin.java.JavaPlugin import org.bukkit.potion.PotionData import org.bukkit.potion.PotionEffect import org.bukkit.potion.PotionEffectType import org.bukkit.potion.PotionType import org.bukkit.util.Vector import kotlinx.coroutines.delay import java.util.concurrent.Callable import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData @OptIn(ExperimentalKotest::class) class OldPotionEffectsIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleOldPotionEffects not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer val excludedPotionTypes = setOf( "AWKWARD", "MUNDANE", "THICK", "WATER", "HARMING", "STRONG_HARMING", "HEALING", "STRONG_HEALING", "INSTANT_DAMAGE", "INSTANT_HEAL", "INSTANT_HEALTH", "UNCRAFTABLE" ) data class PotionCase( val key: String, val baseName: String, val isStrong: Boolean, val isExtended: Boolean, val potion: XPotion, val drinkableTicks: Int, val splashTicks: Int ) data class PotionBaseSnapshot( val baseType: PotionType?, val isUpgraded: Boolean, val isExtended: Boolean ) data class ParsedPotionKey( val baseName: String, val isStrong: Boolean, val isExtended: Boolean, val debugName: String ) fun debugName(baseName: String, isStrong: Boolean, isExtended: Boolean): String { return when { isStrong -> "STRONG_$baseName" isExtended -> "LONG_$baseName" else -> baseName } } suspend fun waitForAttackReady(attacker: Player) { val cooldownMethod = attacker.javaClass.methods.firstOrNull { method -> method.name == "getAttackCooldown" && method.parameterTypes.isEmpty() } if (cooldownMethod == null) { delay(700) return } repeat(40) { val value = (cooldownMethod.invoke(attacker) as? Float) ?: 1.0f if (value >= 0.99f) return delay(50) } } fun resolveBasePotionType(baseName: String, potion: XPotion): PotionType? { return runCatching { PotionType.valueOf(baseName) }.getOrNull() ?: potion.potionType } fun parsePotionKey(key: String): ParsedPotionKey { var name = key.uppercase() var isStrong = false var isExtended = false if (name.startsWith("STRONG_")) { isStrong = true name = name.removePrefix("STRONG_") } else if (name.startsWith("LONG_")) { isExtended = true name = name.removePrefix("LONG_") } val debugName = debugName(name, isStrong, isExtended) return ParsedPotionKey(name, isStrong, isExtended, debugName) } val hasBasePotionType = runCatching { PotionMeta::class.java.getMethod("getBasePotionType") }.isSuccess fun potionSupports(baseName: String, isStrong: Boolean, isExtended: Boolean, potion: XPotion): Boolean { val potionType = resolveBasePotionType(baseName, potion) ?: return false return if (hasBasePotionType) { val resolvedName = when { isStrong -> "STRONG_${potionType.name}" isExtended -> "LONG_${potionType.name}" else -> potionType.name } runCatching { PotionType.valueOf(resolvedName) }.isSuccess } else { runCatching { PotionData(potionType, isExtended, isStrong) }.isSuccess } } fun loadPotionCases(): List { val drinkable = ocm.config.getConfigurationSection("old-potion-effects.potion-durations.drinkable") ?: return emptyList() val splash = ocm.config.getConfigurationSection("old-potion-effects.potion-durations.splash") ?: return emptyList() return drinkable.getKeys(false).mapNotNull { key -> if (!splash.isInt(key)) return@mapNotNull null val parsed = parsePotionKey(key) val potion = XPotion.of(parsed.baseName).orElse(null) ?: return@mapNotNull null if (excludedPotionTypes.contains(parsed.debugName)) return@mapNotNull null if (!potionSupports(parsed.baseName, parsed.isStrong, parsed.isExtended, potion)) return@mapNotNull null PotionCase( key = key, baseName = parsed.baseName, isStrong = parsed.isStrong, isExtended = parsed.isExtended, potion = potion, drinkableTicks = drinkable.getInt(key) * 20, splashTicks = splash.getInt(key) * 20 ) } } fun createPotionItem(material: Material, potionCase: PotionCase): ItemStack { val item = ItemStack(material) val meta = item.itemMeta as PotionMeta val baseType = resolveBasePotionType(potionCase.baseName, potionCase.potion) ?: return item if (hasBasePotionType) { val resolvedName = when { potionCase.isStrong -> "STRONG_${baseType.name}" potionCase.isExtended -> "LONG_${baseType.name}" else -> baseType.name } val potionType = runCatching { PotionType.valueOf(resolvedName) }.getOrElse { baseType } meta.basePotionType = potionType } else { meta.basePotionData = PotionData( baseType, potionCase.isExtended, potionCase.isStrong ) } item.itemMeta = meta return item } fun snapshotBase(meta: PotionMeta): PotionBaseSnapshot { return try { PotionBaseSnapshot(meta.basePotionType, false, false) } catch (e: NoSuchMethodError) { val baseData = meta.basePotionData if (baseData == null) { PotionBaseSnapshot(null, false, false) } else { PotionBaseSnapshot(baseData.type, baseData.isUpgraded, baseData.isExtended) } } } fun expectedEffectTypes(potionType: PotionType): List { return try { potionType.potionEffects.map { it.type } } catch (e: NoSuchMethodError) { listOfNotNull(potionType.effectType) } } fun expectedAmplifier(baseName: String, isStrong: Boolean): Int { return if (isStrong) 1 else 0 } fun assertAdjusted(item: ItemStack, baseName: String, isStrong: Boolean, potion: XPotion, expectedTicks: Int) { val meta = item.itemMeta as PotionMeta val potionType = resolveBasePotionType(baseName, potion) ?: error("Potion type missing for $baseName") val expectedTypes = expectedEffectTypes(potionType) val expectedAmp = expectedAmplifier(baseName, isStrong) meta.customEffects.shouldHaveSize(expectedTypes.size) expectedTypes.forEach { effectType -> val effect = meta.customEffects.firstOrNull { it.type == effectType } effect.shouldNotBe(null) effect!!.duration.shouldBeExactly(expectedTicks) if (baseName == "WEAKNESS") { effect.amplifier.shouldBeLessThanOrEqual(0) } else { effect.amplifier.shouldBeExactly(expectedAmp) } } val baseSnapshot = snapshotBase(meta) baseSnapshot.baseType.shouldBe(PotionType.WATER) baseSnapshot.isUpgraded.shouldBeFalse() baseSnapshot.isExtended.shouldBeFalse() } fun assertUnchanged(item: ItemStack, originalBase: PotionBaseSnapshot) { val meta = item.itemMeta as PotionMeta meta.customEffects.shouldHaveSize(0) val newBase = snapshotBase(meta) newBase.baseType.shouldBe(originalBase.baseType) newBase.isUpgraded.shouldBe(originalBase.isUpgraded) newBase.isExtended.shouldBe(originalBase.isExtended) } fun callConsume(item: ItemStack): ItemStack { val ctor = PlayerItemConsumeEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 3 && Player::class.java.isAssignableFrom(params[0]) && ItemStack::class.java.isAssignableFrom(params[1]) && EquipmentSlot::class.java.isAssignableFrom(params[2]) } val event = if (ctor != null) { ctor.newInstance(player, item, EquipmentSlot.HAND) as PlayerItemConsumeEvent } else { PlayerItemConsumeEvent(player, item) } Bukkit.getPluginManager().callEvent(event) return event.item } fun callThrow(item: ItemStack): ItemStack { val block = player.location.block val face = BlockFace.SELF val ctor = PlayerInteractEvent::class.java.constructors.firstOrNull { constructor -> val params = constructor.parameterTypes params.size == 6 && Player::class.java.isAssignableFrom(params[0]) && params[1] == Action::class.java && ItemStack::class.java.isAssignableFrom(params[2]) && params[3].name.endsWith("Block") && params[4].name.endsWith("BlockFace") && params[5] == EquipmentSlot::class.java } val event = if (ctor != null) { ctor.newInstance(player, Action.RIGHT_CLICK_AIR, item, block, face, EquipmentSlot.HAND) as PlayerInteractEvent } else { PlayerInteractEvent(player, Action.RIGHT_CLICK_AIR, item, block, face) } Bukkit.getPluginManager().callEvent(event) return event.item ?: item } fun callDispense(item: ItemStack): ItemStack { val block = player.world.getBlockAt(player.location.blockX, player.location.blockY, player.location.blockZ) val event = BlockDispenseEvent(block, item, Vector(0, 0, 0)) Bukkit.getPluginManager().callEvent(event) return event.item } fun assertAdjustedOrUnchanged( adjusted: ItemStack, potionCase: PotionCase, originalBase: PotionBaseSnapshot, splash: Boolean ) { val expectedTicks = if (splash) potionCase.splashTicks else potionCase.drinkableTicks if (excludedPotionTypes.contains(debugName(potionCase.baseName, potionCase.isStrong, potionCase.isExtended))) { assertUnchanged(adjusted, originalBase) } else { assertAdjusted(adjusted, potionCase.baseName, potionCase.isStrong, potionCase.potion, expectedTicks) } } fun findSamplePotionCase(): PotionCase { return loadPotionCases().firstOrNull() ?: error("No configured potions available for this server version.") } suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val enabled = ocm.config.getBoolean("old-potion-effects.enabled") val strengthSection = ocm.config.getConfigurationSection("old-potion-effects.strength") val weaknessSection = ocm.config.getConfigurationSection("old-potion-effects.weakness") val drinkSection = ocm.config.getConfigurationSection("old-potion-effects.potion-durations.drinkable") val splashSection = ocm.config.getConfigurationSection("old-potion-effects.potion-durations.splash") val alwaysEnabledModules = ocm.config.getStringList("always_enabled_modules") val disabledModules = ocm.config.getStringList("disabled_modules") val modesetSection = ocm.config.getConfigurationSection("modesets") val strengthSnapshot = strengthSection?.getValues(false) ?: emptyMap() val weaknessSnapshot = weaknessSection?.getValues(false) ?: emptyMap() val drinkSnapshot = drinkSection?.getKeys(false)?.associateWith { drinkSection.get(it) } ?: emptyMap() val splashSnapshot = splashSection?.getKeys(false)?.associateWith { splashSection.get(it) } ?: emptyMap() val modesetSnapshot = modesetSection?.getKeys(false)?.associateWith { key -> ocm.config.getStringList("modesets.$key") } ?: emptyMap() try { block() } finally { ocm.config.set("old-potion-effects.enabled", enabled) strengthSnapshot.forEach { (key, value) -> ocm.config.set("old-potion-effects.strength.$key", value) } weaknessSnapshot.forEach { (key, value) -> ocm.config.set("old-potion-effects.weakness.$key", value) } drinkSnapshot.forEach { (key, value) -> ocm.config.set("old-potion-effects.potion-durations.drinkable.$key", value) } splashSnapshot.forEach { (key, value) -> ocm.config.set("old-potion-effects.potion-durations.splash.$key", value) } ocm.config.set("always_enabled_modules", alwaysEnabledModules) ocm.config.set("disabled_modules", disabledModules) modesetSnapshot.forEach { (key, list) -> ocm.config.set("modesets.$key", list) } modesetSection?.getKeys(false) ?.filterNot { modesetSnapshot.containsKey(it) } ?.forEach { key -> ocm.config.set("modesets.$key", null) } ocm.saveConfig() Config.reload() } } extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun runSyncResult(action: () -> T): T { return if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } } beforeSpec { runSync { val world = Bukkit.getServer().getWorld("world") val location = Location(world, 0.0, 100.0, 0.0) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) player.isOp = true val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "old") setPlayerData(player.uniqueId, playerData) } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "old") setPlayerData(player.uniqueId, playerData) } } context("Drinkable potions") { test("configured drinkable potions are adjusted when duration is loaded") { val cases = loadPotionCases() cases.isNotEmpty().shouldBeTrue() cases.forEach { potionCase -> val item = createPotionItem(Material.POTION, potionCase) val meta = item.itemMeta as PotionMeta val originalBase = snapshotBase(meta) val adjusted = callConsume(item) assertAdjustedOrUnchanged(adjusted, potionCase, originalBase, splash = false) } } } context("Weakness neutralisation") { test("weakness potion does not reduce attack damage") { val weaknessCase = loadPotionCases().firstOrNull { it.baseName == "WEAKNESS" } ?: return@test val item = createPotionItem(Material.POTION, weaknessCase) val adjusted = callConsume(item) val meta = adjusted.itemMeta as PotionMeta val effect = meta.customEffects.firstOrNull { it.type == PotionEffectType.WEAKNESS } ?: error("Weakness effect missing from potion meta") val attackAttribute = XAttribute.ATTACK_DAMAGE.get() ?: error("Attack damage attribute not available") var baseDamage = 0.0 runSync { player.inventory.setItemInMainHand(ItemStack(Material.AIR)) player.activePotionEffects.forEach { player.removePotionEffect(it.type) } baseDamage = player.getAttribute(attackAttribute)?.value ?: error("Attack damage attribute missing on player") player.addPotionEffect(effect, true) } delay(50) var afterDamage = 0.0 runSync { afterDamage = player.getAttribute(attackAttribute)?.value ?: error("Attack damage attribute missing on player") } afterDamage.shouldBe(baseDamage.plusOrMinus(0.0001)) } test("direct weakness effect does not reduce attack damage") { val attackAttribute = XAttribute.ATTACK_DAMAGE.get() ?: error("Attack damage attribute not available") var baseDamage = 0.0 runSync { player.inventory.setItemInMainHand(ItemStack(Material.AIR)) player.activePotionEffects.forEach { player.removePotionEffect(it.type) } baseDamage = player.getAttribute(attackAttribute)?.value ?: error("Attack damage attribute missing on player") player.addPotionEffect(PotionEffect(PotionEffectType.WEAKNESS, 200, -1), true) } delay(50) var afterDamage = 0.0 runSync { afterDamage = player.getAttribute(attackAttribute)?.value ?: error("Attack damage attribute missing on player") } afterDamage.shouldBe(baseDamage.plusOrMinus(0.0001)) } } context("Weakness damage event diagnostic") { test("vanilla damage event for weakness + low damage + no-damage window") { lateinit var attacker: Player lateinit var victim: LivingEntity var attackerFake: FakePlayer? = null val events = mutableListOf() val listener = object : Listener { @EventHandler fun onDamage(event: EntityDamageByEntityEvent) { if (event.entity.uniqueId == victim.uniqueId && event.damager.uniqueId == attacker.uniqueId ) { events.add(event) } } } try { runSync { val world = checkNotNull(Bukkit.getServer().getWorld("world")) val attackerLocation = Location(world, 0.0, 100.0, 0.0).apply { yaw = 0f; pitch = 0f } val victimLocation = Location(world, 1.2, 100.0, 0.0) attackerFake = FakePlayer(testPlugin) attackerFake!!.spawn(attackerLocation) attacker = checkNotNull(Bukkit.getPlayer(attackerFake!!.uuid)) attacker.isOp = true attacker.inventory.clear() attacker.activePotionEffects.forEach { attacker.removePotionEffect(it.type) } attacker.gameMode = GameMode.SURVIVAL val attackerData = getPlayerData(attacker.uniqueId) attackerData.setModesetForWorld(attacker.world.uid, "old") setPlayerData(attacker.uniqueId, attackerData) victim = world.spawn(victimLocation, org.bukkit.entity.Cow::class.java) victim.maximumNoDamageTicks = 20 victim.noDamageTicks = 0 victim.isInvulnerable = false victim.health = victim.maxHealth Bukkit.getPluginManager().registerEvents(listener, testPlugin) } delay(200) fun attackDamage(): Double { val attribute = XAttribute.ATTACK_DAMAGE.get() ?: error("Attack damage attribute not available") return attacker.getAttribute(attribute)?.value ?: 0.0 } fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") // Deprecated constructor kept for older server compatibility in tests. val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = attacker.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun record(label: String, expectedDamage: Double, action: () -> Unit): Boolean { val before = events.size runSync { Bukkit.getScheduler().runTask(testPlugin, Runnable { action() }) } delay(150) val fired = events.size > before testPlugin.logger.info( "Weakness diagnostic [$label] fired=$fired " + "noDamageTicks=${victim.noDamageTicks} lastDamage=${victim.lastDamage} " + "eventType=${events.lastOrNull()?.javaClass?.simpleName} " + "cause=${events.lastOrNull()?.cause} " + "eventDamage=${events.lastOrNull()?.damage} " + "finalDamage=${events.lastOrNull()?.finalDamage} " + "damagerType=${events.lastOrNull()?.damager?.javaClass?.simpleName} " + "damagerId=${events.lastOrNull()?.damager?.uniqueId} " + "inputDamage=$expectedDamage" ) return fired } runSync { val weapon = ItemStack(Material.DIAMOND_SWORD) prepareWeapon(weapon) attacker.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) attacker.updateInventory() attacker.isInvulnerable = false attacker.health = attacker.maxHealth victim.noDamageTicks = 0 victim.lastDamage = 0.0 } delay(100) val baselineDamage = attackDamage() waitForAttackReady(attacker) record("baseline", baselineDamage) { attackCompat(attacker, victim) } runSync { attacker.activePotionEffects.forEach { attacker.removePotionEffect(it.type) } attacker.addPotionEffect(PotionEffect(XPotion.WEAKNESS.get()!!, 200, 0)) val lowItem = ItemStack(Material.STONE_SWORD) prepareWeapon(lowItem) attacker.inventory.setItemInMainHand(lowItem) applyAttackDamageModifiers(lowItem) attacker.updateInventory() attacker.isInvulnerable = false attacker.health = attacker.maxHealth victim.noDamageTicks = 0 victim.lastDamage = 0.0 } delay(100) val weakDamage = attackDamage() waitForAttackReady(attacker) record("weakness-no-invuln", weakDamage) { attackCompat(attacker, victim) } runSync { victim.noDamageTicks = victim.maximumNoDamageTicks victim.lastDamage = 20.0 } delay(100) waitForAttackReady(attacker) record("weakness-invuln", weakDamage) { attackCompat(attacker, victim) } } finally { HandlerList.unregisterAll(listener) runSync { attackerFake?.removePlayer() victim.remove() } } } } context("Splash potions") { test("player throws splash potions with module durations") { val cases = loadPotionCases() cases.forEach { potionCase -> val item = createPotionItem(Material.SPLASH_POTION, potionCase) val meta = item.itemMeta as PotionMeta val originalBase = snapshotBase(meta) val adjusted = callThrow(item) assertAdjustedOrUnchanged(adjusted, potionCase, originalBase, splash = true) } } test("dispenser does not mutate splash potions without setItem") { val cases = loadPotionCases() cases.forEach { potionCase -> val item = createPotionItem(Material.SPLASH_POTION, potionCase) val meta = item.itemMeta as PotionMeta val originalBase = snapshotBase(meta) val adjusted = callDispense(item) assertUnchanged(adjusted, originalBase) } } } context("Lingering potions") { test("player throws lingering potions with module splash durations") { val cases = loadPotionCases() cases.forEach { potionCase -> val item = createPotionItem(Material.LINGERING_POTION, potionCase) val meta = item.itemMeta as PotionMeta val originalBase = snapshotBase(meta) val adjusted = callThrow(item) assertAdjustedOrUnchanged(adjusted, potionCase, originalBase, splash = true) } } test("dispenser does not mutate lingering potions without setItem") { val cases = loadPotionCases() cases.forEach { potionCase -> val item = createPotionItem(Material.LINGERING_POTION, potionCase) val meta = item.itemMeta as PotionMeta val originalBase = snapshotBase(meta) val adjusted = callDispense(item) assertUnchanged(adjusted, originalBase) } } } context("Excluded potions") { test("excluded potion types are not modified") { excludedPotionTypes.forEach { name -> val potionType = runCatching { PotionType.valueOf(name) }.getOrNull() ?: return@forEach val item = ItemStack(Material.POTION) val meta = item.itemMeta as PotionMeta val originalBase = runCatching { try { meta.basePotionType = potionType } catch (e: NoSuchMethodError) { meta.basePotionData = PotionData(potionType, false, false) } snapshotBase(meta) }.getOrElse { return@forEach } item.itemMeta = meta val adjusted = callConsume(item) assertUnchanged(adjusted, originalBase) } } } context("Missing config") { test("missing potion entry leaves potion unchanged") { withConfig { val potionCase = findSamplePotionCase() ocm.config.set("old-potion-effects.potion-durations.drinkable.${potionCase.key}", null) ocm.config.set("old-potion-effects.potion-durations.splash.${potionCase.key}", null) module.reload() val item = createPotionItem(Material.POTION, potionCase) val originalBase = snapshotBase(item.itemMeta as PotionMeta) val adjusted = callConsume(item) assertUnchanged(adjusted, originalBase) } } } context("Module disabled") { test("disabled via modeset leaves potions unchanged") { val potionCase = findSamplePotionCase() val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "new") setPlayerData(player.uniqueId, playerData) val item = createPotionItem(Material.POTION, potionCase) val originalBase = snapshotBase(item.itemMeta as PotionMeta) val adjusted = callConsume(item) assertUnchanged(adjusted, originalBase) } test("disabled via config leaves potions unchanged") { withConfig { val potionCase = findSamplePotionCase() val disabled = ocm.config.getStringList("disabled_modules") .filterNot { it.equals("old-potion-effects", true) } .toMutableList() disabled.add("old-potion-effects") ocm.config.set("disabled_modules", disabled) ocm.config.set( "always_enabled_modules", ocm.config.getStringList("always_enabled_modules") .filterNot { it.equals("old-potion-effects", true) } ) val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing 'modesets' section in config") modesetsSection.getKeys(false).forEach { key -> val modules = ocm.config.getStringList("modesets.$key") .filterNot { it.equals("old-potion-effects", true) } ocm.config.set("modesets.$key", modules) } ocm.saveConfig() Config.reload() val item = createPotionItem(Material.POTION, potionCase) val originalBase = snapshotBase(item.itemMeta as PotionMeta) val adjusted = callConsume(item) assertUnchanged(adjusted, originalBase) } } } context("Strength and weakness modifiers") { test("vanilla strength addend applies when old-potion-effects is disabled") { withConfig { val disabled = ocm.config.getStringList("disabled_modules") .filterNot { it.equals("old-potion-effects", true) } .toMutableList() disabled.add("old-potion-effects") ocm.config.set("disabled_modules", disabled) ocm.config.set( "always_enabled_modules", ocm.config.getStringList("always_enabled_modules") .filterNot { it.equals("old-potion-effects", true) } ) val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing 'modesets' section in config") modesetsSection.getKeys(false).forEach { key -> val modules = ocm.config.getStringList("modesets.$key") .filterNot { it.equals("old-potion-effects", true) } ocm.config.set("modesets.$key", modules) } ocm.saveConfig() Config.reload() val world = checkNotNull(Bukkit.getServer().getWorld("world")) val weapon = ItemStack(Material.DIAMOND_SWORD) fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun captureDamage(victim: LivingEntity): Double { val events = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == player.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { waitForAttackReady(player) runSync { attackCompat(player, victim) } delay(200) } finally { HandlerList.unregisterAll(listener) } val event = events.lastOrNull() ?: error("Expected a damage event for vanilla strength test") return event.damage } prepareWeapon(weapon) runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) player.updateInventory() player.isSprinting = false player.fallDistance = 0f player.velocity = Vector(0.0, 0.0, 0.0) player.isInvulnerable = false player.health = player.maxHealth } val baselineVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } val baselineDamage = captureDamage(baselineVictim) runSync { baselineVictim.remove() } val strengthVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 1), true) } delay(50) val strengthDamage = captureDamage(strengthVictim) runSync { strengthVictim.remove() } val delta = strengthDamage - baselineDamage delta.shouldBe(6.0.plusOrMinus(0.0001)) } } test("damage modifiers are applied from config") { withConfig { val strengthModifier = 2.4 val weaknessModifier = -0.75 ocm.config.set("old-potion-effects.strength.modifier", strengthModifier) ocm.config.set("old-potion-effects.strength.multiplier", false) ocm.config.set("old-potion-effects.strength.addend", true) ocm.config.set("old-potion-effects.weakness.modifier", weaknessModifier) ocm.config.set("old-potion-effects.weakness.multiplier", true) module.reload() player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 0)) player.addPotionEffect(PotionEffect(XPotion.WEAKNESS.get()!!, 200, 0)) val defender = player val event = OCMEntityDamageByEntityEvent( player, defender, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0 ) Bukkit.getPluginManager().callEvent(event) event.strengthModifier.shouldBe(strengthModifier) event.isStrengthModifierMultiplier.shouldBeFalse() event.isStrengthModifierAddend.shouldBeTrue() event.weaknessModifier.shouldBe(weaknessModifier) event.isWeaknessModifierMultiplier.shouldBeTrue() event.weaknessLevel.shouldBe(1) } } test("strength addend scales per level for Strength II") { withConfig { val strengthModifier = 2.0 ocm.config.set("old-potion-effects.strength.modifier", strengthModifier) ocm.config.set("old-potion-effects.strength.multiplier", false) ocm.config.set("old-potion-effects.strength.addend", true) module.reload() val world = checkNotNull(Bukkit.getServer().getWorld("world")) val weapon = ItemStack(Material.DIAMOND_SWORD) fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun captureDamage(victim: LivingEntity): Double { val events = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == player.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { waitForAttackReady(player) runSync { attackCompat(player, victim) } delay(200) } finally { HandlerList.unregisterAll(listener) } val event = events.lastOrNull() ?: error("Expected a damage event for strength addend test") return event.damage } prepareWeapon(weapon) runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) player.updateInventory() player.isSprinting = false player.fallDistance = 0f player.velocity = Vector(0.0, 0.0, 0.0) player.isInvulnerable = false player.health = player.maxHealth } val baselineVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } val baselineDamage = captureDamage(baselineVictim) runSync { baselineVictim.remove() } val strengthVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 1), true) } delay(50) val strengthDamage = captureDamage(strengthVictim) runSync { strengthVictim.remove() } val delta = strengthDamage - baselineDamage delta.shouldBe((strengthModifier * 2).plusOrMinus(0.0001)) } } test("strength addend scales per level for Strength III") { withConfig { val strengthModifier = 2.0 ocm.config.set("old-potion-effects.strength.modifier", strengthModifier) ocm.config.set("old-potion-effects.strength.multiplier", false) ocm.config.set("old-potion-effects.strength.addend", true) module.reload() val world = checkNotNull(Bukkit.getServer().getWorld("world")) val weapon = ItemStack(Material.DIAMOND_SWORD) fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun captureDamage(victim: LivingEntity): Double { val events = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == player.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { waitForAttackReady(player) runSync { attackCompat(player, victim) } delay(200) } finally { HandlerList.unregisterAll(listener) } val event = events.lastOrNull() ?: error("Expected a damage event for strength addend test") return event.damage } prepareWeapon(weapon) runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) player.updateInventory() player.isSprinting = false player.fallDistance = 0f player.velocity = Vector(0.0, 0.0, 0.0) player.isInvulnerable = false player.health = player.maxHealth } val baselineVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } val baselineDamage = captureDamage(baselineVictim) runSync { baselineVictim.remove() } val strengthVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 2), true) } delay(50) val strengthDamage = captureDamage(strengthVictim) runSync { strengthVictim.remove() } val delta = strengthDamage - baselineDamage delta.shouldBe((strengthModifier * 3).plusOrMinus(0.0001)) } } test("strength addend respects configured modifier value") { withConfig { val strengthModifier = 4.5 ocm.config.set("old-potion-effects.strength.modifier", strengthModifier) ocm.config.set("old-potion-effects.strength.multiplier", false) ocm.config.set("old-potion-effects.strength.addend", true) module.reload() val world = checkNotNull(Bukkit.getServer().getWorld("world")) val weapon = ItemStack(Material.DIAMOND_SWORD) fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun captureDamage(victim: LivingEntity): Double { val events = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == player.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { waitForAttackReady(player) runSync { attackCompat(player, victim) } delay(200) } finally { HandlerList.unregisterAll(listener) } val event = events.lastOrNull() ?: error("Expected a damage event for strength addend test") return event.damage } prepareWeapon(weapon) runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) player.updateInventory() player.isSprinting = false player.fallDistance = 0f player.velocity = Vector(0.0, 0.0, 0.0) player.isInvulnerable = false player.health = player.maxHealth } val baselineVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } val baselineDamage = captureDamage(baselineVictim) runSync { baselineVictim.remove() } val strengthVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 0), true) } delay(50) val strengthDamage = captureDamage(strengthVictim) runSync { strengthVictim.remove() } val delta = strengthDamage - baselineDamage delta.shouldBe(strengthModifier.plusOrMinus(0.0001)) } } test("strength multiplier scales base damage") { withConfig { val strengthModifier = 1.4 ocm.config.set("old-potion-effects.strength.modifier", strengthModifier) ocm.config.set("old-potion-effects.strength.multiplier", true) ocm.config.set("old-potion-effects.strength.addend", false) module.reload() val world = checkNotNull(Bukkit.getServer().getWorld("world")) val weapon = ItemStack(Material.DIAMOND_SWORD) fun prepareWeapon(item: ItemStack) { val meta = item.itemMeta ?: return @Suppress("DEPRECATION") val speedModifier = createAttributeModifier( name = "speed", amount = 1000.0, operation = AttributeModifier.Operation.ADD_NUMBER, slot = EquipmentSlot.HAND ) val attackSpeedAttribute = XAttribute.ATTACK_SPEED.get() ?: return addAttributeModifierCompat(meta, attackSpeedAttribute, speedModifier) item.itemMeta = meta } fun applyAttackDamageModifiers(item: ItemStack) { val attackDamageAttribute = XAttribute.ATTACK_DAMAGE.get() ?: return val attackAttribute = player.getAttribute(attackDamageAttribute) ?: return val modifiers = getDefaultAttributeModifiersCompat(item, EquipmentSlot.HAND, attackDamageAttribute) modifiers.forEach { modifier -> attackAttribute.removeModifier(modifier) attackAttribute.addModifier(modifier) } } suspend fun captureDamage(victim: LivingEntity): Double { val events = mutableListOf() val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onDamage(event: EntityDamageByEntityEvent) { if (event.damager.uniqueId == player.uniqueId && event.entity.uniqueId == victim.uniqueId ) { events.add(event) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { waitForAttackReady(player) runSync { attackCompat(player, victim) } delay(200) } finally { HandlerList.unregisterAll(listener) } val event = events.lastOrNull() ?: error("Expected a damage event for strength multiplier test") return event.damage } prepareWeapon(weapon) runSync { player.inventory.clear() player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.inventory.setItemInMainHand(weapon) applyAttackDamageModifiers(weapon) player.updateInventory() player.isSprinting = false player.fallDistance = 0f player.velocity = Vector(0.0, 0.0, 0.0) player.isInvulnerable = false player.health = player.maxHealth } val baselineVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } val baselineDamage = captureDamage(baselineVictim) runSync { baselineVictim.remove() } val strengthVictim = runSyncResult { world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Cow::class.java).apply { maximumNoDamageTicks = 20 noDamageTicks = 0 isInvulnerable = false health = maxHealth } } runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(XPotion.STRENGTH.get()!!, 200, 1), true) } delay(50) val strengthDamage = captureDamage(strengthVictim) runSync { strengthVictim.remove() } val ratio = strengthDamage / baselineDamage ratio.shouldBe((strengthModifier * 2).plusOrMinus(0.0001)) } } test("weakness II is capped to level one for old modifier logic") { withConfig { val weaknessModifier = -0.5 ocm.config.set("old-potion-effects.weakness.modifier", weaknessModifier) ocm.config.set("old-potion-effects.weakness.multiplier", false) module.reload() val weakness = XPotion.WEAKNESS.get() ?: error("Weakness potion missing") runSync { player.addPotionEffect(PotionEffect(weakness, 200, 1), true) } val event = OCMEntityDamageByEntityEvent( player, player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0 ) Bukkit.getPluginManager().callEvent(event) event.hasWeakness().shouldBeTrue() event.weaknessModifier.shouldBe(weaknessModifier) event.isWeaknessModifierMultiplier.shouldBeFalse() event.weaknessLevel.shouldBe(1) } } test("high amplifier weakness does not distort base damage reconstruction") { withConfig { val weakness = XPotion.WEAKNESS.get() ?: error("Weakness potion missing") var baseLevel0 = 0.0 var baseLevel67 = 0.0 runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(weakness, 200, 0), true) } val eventLevel0 = OCMEntityDamageByEntityEvent( player, player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0 ) Bukkit.getPluginManager().callEvent(eventLevel0) baseLevel0 = eventLevel0.baseDamage runSync { player.activePotionEffects.forEach { player.removePotionEffect(it.type) } player.addPotionEffect(PotionEffect(weakness, 200, 67), true) } val eventLevel67 = OCMEntityDamageByEntityEvent( player, player, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0 ) Bukkit.getPluginManager().callEvent(eventLevel67) baseLevel67 = eventLevel67.baseDamage baseLevel67.shouldBe(baseLevel0.plusOrMinus(0.0001)) } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/OldToolDamageMobIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Entity import org.bukkit.entity.LivingEntity import org.bukkit.entity.Villager import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.lang.reflect.Method import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class OldToolDamageMobIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod( testPlugin, Callable { action() null }, ).get() } } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val damagesSection = ocm.config.getConfigurationSection("old-tool-damage.damages") val damagesSnapshot = damagesSection?.getKeys(false)?.associateWith { damagesSection.get(it) } ?: emptyMap() val disabledModules = ocm.config.getStringList("disabled_modules") val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing 'modesets' section in config") val modesetSnapshot = modesetsSection.getKeys(false).associateWith { key -> ocm.config.getStringList("modesets.$key") } fun reloadAll() { ocm.saveConfig() Config.reload() } try { block() } finally { damagesSnapshot.forEach { (key, value) -> ocm.config.set("old-tool-damage.damages.$key", value) } ocm.config.set("disabled_modules", disabledModules) modesetSnapshot.forEach { (key, list) -> ocm.config.set("modesets.$key", list) } reloadAll() } } fun mobMethodSignature(method: Method): String { val params = method.parameterTypes.joinToString(",") { it.name } return "${method.declaringClass.name}#${method.name}($params):${method.returnType.name}" } fun mobCollectAllMethods(start: Class<*>): List { val methods = LinkedHashMap() var current: Class<*>? = start while (current != null) { current.declaredMethods.forEach { method -> methods.putIfAbsent(mobMethodSignature(method), method) } current = current.superclass } start.methods.forEach { method -> methods.putIfAbsent(mobMethodSignature(method), method) } return methods.values.toList() } fun mobScoreAttackMethod(method: Method): Int { var score = 0 if (method.name == "attack") score += 100 if (method.name == "a") score += 80 val param = method.parameterTypes[0] if (param.simpleName == "Entity") score += 40 if (param.simpleName.contains("Entity")) score += 10 if (method.returnType == Void.TYPE) score += 10 if (method.returnType == java.lang.Boolean.TYPE) score += 8 val declaring = method.declaringClass.simpleName if (declaring.contains("EntityInsentient")) score += 20 if (declaring.contains("Mob")) score += 10 return score } fun resolveDebugFile(): java.io.File { val versionTag = Bukkit.getBukkitVersion().replace(Regex("[^A-Za-z0-9_.-]"), "_") val runDir = java.io.File(System.getProperty("user.dir")) val repoRoot = runDir.parentFile?.parentFile ?: runDir return java.io.File(repoRoot, "build/mob-tool-damage-debug-$versionTag.txt") } fun attackCompat( attacker: LivingEntity, target: Entity, ): Boolean { val handleMethod = attacker.javaClass.methods.firstOrNull { method -> method.name == "getHandle" && method.parameterTypes.isEmpty() } ?: error("Failed to resolve CraftEntity#getHandle for ${attacker.javaClass.name}") val attackerHandle = handleMethod.invoke(attacker) ?: error("CraftEntity#getHandle returned null for ${attacker.javaClass.name}") val targetHandle = target.javaClass.methods .firstOrNull { method -> method.name == "getHandle" && method.parameterTypes.isEmpty() }?.invoke(target) ?: error("Failed to resolve CraftEntity#getHandle for ${target.javaClass.name}") val candidates = listOfNotNull( Reflector.getMethodAssignable(attackerHandle.javaClass, "attack", targetHandle.javaClass), Reflector.getMethodAssignable(attackerHandle.javaClass, "a", targetHandle.javaClass), ).ifEmpty { mobCollectAllMethods(attackerHandle.javaClass) .asSequence() .filter { it.parameterCount == 1 } .filter { it.parameterTypes[0].isAssignableFrom(targetHandle.javaClass) } .filter { it.returnType == Void.TYPE || it.returnType == java.lang.Boolean.TYPE } .sortedByDescending { mobScoreAttackMethod(it) } .toList() } candidates.forEach { it.isAccessible = true } for (method in candidates) { try { val result = method.invoke(attackerHandle, targetHandle) if (result is Boolean && !result) { continue } return true } catch (ignored: Exception) { // try next } } return false } suspend fun captureVindicatorBaseDamage( debugFile: java.io.File, label: String, ): Double { val mobClass: Class = try { @Suppress("UNCHECKED_CAST") Class.forName("org.bukkit.entity.Vindicator") as Class } catch (_: ClassNotFoundException) { org.bukkit.entity.Zombie::class.java } lateinit var victim: Villager lateinit var mob: LivingEntity runSync { val world = checkNotNull(Bukkit.getWorld("world")) val victimLocation = Location(world, 0.0, 100.0, 0.0) val mobLocation = Location(world, 1.1, 100.0, 0.0) victim = world.spawn(victimLocation, Villager::class.java) victim.isInvulnerable = false victim.health = victim.maxHealth victim.maximumNoDamageTicks = 0 victim.noDamageTicks = 0 mob = world.spawn(mobLocation, mobClass) mob.isSilent = true mob.equipment?.setItemInMainHand(ItemStack(Material.IRON_AXE)) mob.maximumNoDamageTicks = 0 mob.noDamageTicks = 0 } try { val baseDamage = NewWeaponDamage.getDamage(Material.IRON_AXE) // vanilla 1.9 base val event = EntityDamageByEntityEvent( mob, victim, org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, baseDamage.toDouble(), ) runSync { Bukkit.getPluginManager().callEvent(event) } val moduleEnabled = Config.moduleEnabled("old-tool-damage", victim.world) debugFile.parentFile?.mkdirs() debugFile.appendText( "label=$label base=${event.damage} raw=${event.damage} weapon=IRON_AXE enabled=$moduleEnabled\n", ) return event.damage } finally { runSync { mob.remove() victim.remove() } } } test("mob tool damage follows configured old-tool-damage values") { withConfig { val debugFile = resolveDebugFile() debugFile.parentFile?.mkdirs() debugFile.writeText("start\n") try { ocm.config.set( "disabled_modules", ocm.config .getStringList("disabled_modules") .filterNot { it.equals("old-tool-damage", true) }, ) val oldModeset = ocm.config .getStringList("modesets.old") .filterNot { it.equals("old-tool-damage", true) } .toMutableList() oldModeset.add("old-tool-damage") ocm.config.set("modesets.old", oldModeset) ocm.config.set("old-tool-damage.damages.IRON_AXE", 1) ocm.saveConfig() Config.reload() val lowDamage = try { captureVindicatorBaseDamage(debugFile, "low") } catch (e: Throwable) { debugFile.appendText("low-error=${e::class.java.simpleName}: ${e.message}\n") throw e } ocm.config.set("old-tool-damage.damages.IRON_AXE", 20) ocm.saveConfig() Config.reload() val highDamage = try { captureVindicatorBaseDamage(debugFile, "high") } catch (e: Throwable) { debugFile.appendText("high-error=${e::class.java.simpleName}: ${e.message}\n") throw e } val delta = highDamage - lowDamage debugFile.appendText("delta=$delta low=$lowDamage high=$highDamage\n") if (delta <= 10.0) { error("Mob tool damage delta too small: delta=$delta low=$lowDamage high=$highDamage") } } catch (e: Throwable) { debugFile.appendText("test-error=${e::class.java.simpleName}: ${e.message}\n") throw e } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/PacketCancellationIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import com.github.retrooper.packetevents.PacketEvents import com.github.retrooper.packetevents.event.PacketSendEvent import com.github.retrooper.packetevents.manager.server.ServerVersion import com.github.retrooper.packetevents.netty.buffer.ByteBufHelper import com.github.retrooper.packetevents.protocol.ConnectionState import com.github.retrooper.packetevents.protocol.PacketSide import com.github.retrooper.packetevents.protocol.packettype.PacketType import com.github.retrooper.packetevents.protocol.packettype.PacketTypeCommon import com.github.retrooper.packetevents.protocol.particle.Particle import com.github.retrooper.packetevents.protocol.particle.type.ParticleTypes import com.github.retrooper.packetevents.protocol.sound.Sound import com.github.retrooper.packetevents.protocol.sound.SoundCategory import com.github.retrooper.packetevents.protocol.sound.Sounds import com.github.retrooper.packetevents.protocol.player.User import com.github.retrooper.packetevents.protocol.player.UserProfile import com.github.retrooper.packetevents.util.Vector3d import com.github.retrooper.packetevents.util.Vector3f import com.github.retrooper.packetevents.util.Vector3i import com.github.retrooper.packetevents.wrapper.PacketWrapper import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerParticle import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerSoundEffect import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleAttackSounds import kernitus.plugin.OldCombatMechanics.module.ModuleSwordSweepParticles import kernitus.plugin.OldCombatMechanics.utilities.Config import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.entity.Player import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class PacketCancellationIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = Bukkit.getPluginManager().getPlugin("OldCombatMechanics") as OCMMain fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { require(PacketEvents.getAPI().isInitialized) { "PacketEvents not initialised for integration tests." } } suspend fun withModuleState( moduleName: String, enabled: Boolean, preReload: (() -> Unit)? = null, postRestore: (() -> Unit)? = null, block: suspend () -> Unit ) { val disabledOriginal = ocm.config.getStringList("disabled_modules") val alwaysOriginal = ocm.config.getStringList("always_enabled_modules") val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing modesets section in config") val modesetsOriginal = modesetsSection.getKeys(false).associateWith { ocm.config.getStringList("modesets.$it") } fun List.withoutModule(): MutableList = filterNot { it.equals(moduleName, true) }.toMutableList() val disabledUpdated = disabledOriginal.withoutModule() val alwaysUpdated = alwaysOriginal.withoutModule() if (enabled) { alwaysUpdated.add(moduleName) } else { disabledUpdated.add(moduleName) } ocm.config.set("disabled_modules", disabledUpdated) ocm.config.set("always_enabled_modules", alwaysUpdated) modesetsOriginal.keys.forEach { key -> val filtered = modesetsOriginal.getValue(key).withoutModule() ocm.config.set("modesets.$key", filtered) } preReload?.invoke() ocm.saveConfig() Config.reload() delay(2 * 50L) try { block() } finally { ocm.config.set("disabled_modules", disabledOriginal) ocm.config.set("always_enabled_modules", alwaysOriginal) modesetsOriginal.forEach { (key, value) -> ocm.config.set("modesets.$key", value) } postRestore?.invoke() ocm.saveConfig() Config.reload() delay(2 * 50L) } } fun spawnFakePlayer(): Pair { val world = Bukkit.getWorld("world") ?: error("world not loaded") val location = Location(world, 0.0, 120.0, 0.0, 0f, 0f) val fake = FakePlayer(testPlugin) fake.spawn(location) val player = Bukkit.getPlayer(fake.uuid) ?: error("Player not found after spawn") return fake to player } suspend fun removeFakePlayer(fake: FakePlayer) { runSync { fake.removePlayer() } delay(2 * 50L) } suspend fun withBlockedSounds(module: ModuleAttackSounds, blocked: Set, block: suspend () -> Unit) { val field = module.javaClass.getDeclaredField("blockedSounds") field.isAccessible = true @Suppress("UNCHECKED_CAST") val current = field.get(module) as MutableSet val snapshot = current.toSet() current.clear() current.addAll(blocked) try { block() } finally { current.clear() current.addAll(snapshot) } } fun createPacketSendEvent( packetId: Int, packetType: PacketTypeCommon, serverVersion: ServerVersion, channel: Any, user: User, player: Player, buffer: Any ): PacketSendEvent { val constructor = PacketSendEvent::class.java.getDeclaredConstructor( Int::class.javaPrimitiveType, PacketTypeCommon::class.java, ServerVersion::class.java, Any::class.java, User::class.java, Any::class.java, Any::class.java ) constructor.isAccessible = true return constructor.newInstance( packetId, packetType, serverVersion, channel, user, player, buffer ) as PacketSendEvent } fun runPacketThroughPacketEvents(player: Player, wrapper: PacketWrapper<*>): Boolean { val api = PacketEvents.getAPI() val channel = api.playerManager.getChannel(player) ?: error("Missing channel for ${player.name}") val serverVersion = api.serverManager.version val user = User( channel, ConnectionState.PLAY, serverVersion.toClientVersion(), UserProfile(player.uniqueId, player.name) ) user.setEncoderState(ConnectionState.PLAY) user.setDecoderState(ConnectionState.PLAY) user.setEntityId(player.entityId) val buffers = api.protocolManager.transformWrappers(wrapper, channel, true) val buffer = buffers.firstOrNull() ?: error("No buffer produced for ${wrapper.javaClass.simpleName}") val packetId = ByteBufHelper.readVarInt(buffer) val packetType = PacketType.getById(PacketSide.SERVER, ConnectionState.PLAY, user.clientVersion, packetId) ?: error("No packet type for id $packetId in ${user.clientVersion}") val event = createPacketSendEvent(packetId, packetType, serverVersion, channel, user, player, buffer) api.eventManager.callEvent(event) return event.isCancelled } fun soundName(sound: Sound): String = sound.soundId.toString() test("sweep particles are cancelled when module enabled") { withModuleState("disable-sword-sweep-particles", enabled = true) { val (fake, player) = runSync { spawnFakePlayer() } try { val particle = Particle(ParticleTypes.SWEEP_ATTACK) val position = Vector3d(player.location.x, player.location.y, player.location.z) val offset = Vector3f(0f, 0f, 0f) val wrapper = WrapperPlayServerParticle(particle, false, position, offset, 0.0f, 1) val cancelled = runPacketThroughPacketEvents(player, wrapper) cancelled shouldBe true } finally { removeFakePlayer(fake) } } } test("sweep particles are not cancelled when module disabled") { withModuleState("disable-sword-sweep-particles", enabled = false) { val (fake, player) = runSync { spawnFakePlayer() } try { val particle = Particle(ParticleTypes.FLAME) val position = Vector3d(player.location.x, player.location.y, player.location.z) val offset = Vector3f(0f, 0f, 0f) val wrapper = WrapperPlayServerParticle(particle, false, position, offset, 0.0f, 1) val cancelled = runPacketThroughPacketEvents(player, wrapper) cancelled shouldBe false } finally { removeFakePlayer(fake) } } } test("blocked attack sounds are cancelled when module enabled") { withModuleState("disable-attack-sounds", enabled = true) { val (fake, player) = runSync { spawnFakePlayer() } try { val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModuleAttackSounds not registered") val sound = Sounds.ENTITY_PLAYER_ATTACK_STRONG val position = Vector3i(player.location.blockX, player.location.blockY, player.location.blockZ) val wrapper = WrapperPlayServerSoundEffect(sound, SoundCategory.PLAYER, position, 0.37f, 0.71f) withBlockedSounds(module, setOf(soundName(sound))) { val cancelled = runPacketThroughPacketEvents(player, wrapper) cancelled shouldBe true } } finally { removeFakePlayer(fake) } } } test("non-blocked attack sounds are not cancelled when module enabled") { withModuleState("disable-attack-sounds", enabled = true) { val (fake, player) = runSync { spawnFakePlayer() } try { val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModuleAttackSounds not registered") val blockedSound = Sounds.ENTITY_PLAYER_ATTACK_STRONG val sound = Sounds.ENTITY_PLAYER_LEVELUP val position = Vector3i(player.location.blockX, player.location.blockY, player.location.blockZ) val wrapper = WrapperPlayServerSoundEffect(sound, SoundCategory.PLAYER, position, 0.43f, 0.21f) withBlockedSounds(module, setOf(soundName(blockedSound))) { val cancelled = runPacketThroughPacketEvents(player, wrapper) cancelled shouldBe false } } finally { removeFakePlayer(fake) } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/PaperSwordBlockingDamageReductionIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.shouldBeLessThan import io.kotest.matchers.doubles.shouldBeGreaterThan import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleSwordBlocking import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.block.Action import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class PaperSwordBlockingDamageReductionIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler() .callSyncMethod(testPlugin, Callable { action() }) .get() } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } fun paperDataComponentApiPresent(): Boolean { return try { Class.forName("io.papermc.paper.datacomponent.DataComponentTypes") true } catch (_: Throwable) { false } } fun setModeset(player: Player, name: String) { val data = getPlayerData(player.uniqueId) data.setModesetForWorld(player.world.uid, name) setPlayerData(player.uniqueId, data) } fun equipSword(player: Player, material: Material) { player.inventory.setItemInMainHand(ItemStack(material)) player.updateInventory() } fun rightClickMainHand(player: Player) { val event = PlayerInteractEvent( player, Action.RIGHT_CLICK_AIR, player.inventory.itemInMainHand, null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND ) Bukkit.getPluginManager().callEvent(event) } lateinit var defenderFake: FakePlayer lateinit var defender: Player lateinit var module: ModuleSwordBlocking beforeSpec { runSync { module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModuleSwordBlocking not registered") val world = Bukkit.getWorld("world") ?: error("world missing") val base = Location(world, 0.0, 100.0, 0.0) defenderFake = FakePlayer(testPlugin) defenderFake.spawn(base) defender = Bukkit.getPlayer(defenderFake.uuid) ?: error("defender not found") defender.gameMode = GameMode.SURVIVAL defender.maximumNoDamageTicks = 20 defender.noDamageTicks = 0 defender.isInvulnerable = false defender.inventory.clear() setModeset(defender, "old") } } afterSpec { runSync { defenderFake.removePlayer() } } test("Paper sword blocking sets BLOCKING modifier negative on hit") { if (!paperDataComponentApiPresent()) { println("Skipping: Paper DataComponent API not present") return@test } runSync { equipSword(defender, Material.DIAMOND_SWORD) defender.inventory.setItemInOffHand(ItemStack(Material.AIR)) } runSync { rightClickMainHand(defender) } delayTicks(2) val offhandAfter = runSync { defender.inventory.itemInOffHand.type } if (offhandAfter == Material.SHIELD) { println("Skipping: legacy shield swap path is active on this server") return@test } runSync { // The bug we saw in live logs: the sword can animate as BLOCK, but the server may not recognise // it as "blocking" for damage reduction (BLOCKING stays 0). This asserts the Paper path is // actually recognised server-side. module.isPaperSwordBlocking(defender) shouldBe true } val zombie = runSync { defender.world.spawn(defender.location.clone().add(0.0, 0.0, 1.0), org.bukkit.entity.Zombie::class.java) } try { // Use a synthetic event here. We specifically care about the Paper sword-block detection and the // computed reduction. Whether Bukkit considers the BLOCKING modifier "applicable" is decided by // the server's internal damage pipeline and can differ for synthetic events vs real hits. val event = runSync { org.bukkit.event.entity.EntityDamageByEntityEvent( zombie, defender, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 2.5 ) } val reduction = runSync { module.applyPaperBlockingReduction(event, 2.5) } reduction shouldBeGreaterThan 0.0 // Also sanity-check sign: the module is supposed to write BLOCKING as a negative modifier downstream. // (We don't assert it here because synthetic events may not expose/apply that modifier consistently.) reduction shouldBeLessThan 2.5 } finally { runSync { zombie.remove() } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/PlayerKnockbackIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModulePlayerKnockback import com.cryptomorin.xseries.XAttribute import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.attribute.AttributeModifier import org.bukkit.entity.Player import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.player.PlayerVelocityEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.util.Vector import java.util.UUID import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class PlayerKnockbackIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModulePlayerKnockback not registered") lateinit var attacker: Player lateinit var victim: Player lateinit var fakeAttacker: FakePlayer lateinit var fakeVictim: FakePlayer fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } suspend fun TestScope.withConfig(block: suspend TestScope.() -> Unit) { val horizontal = ocm.config.getDouble("old-player-knockback.knockback-horizontal") val vertical = ocm.config.getDouble("old-player-knockback.knockback-vertical") val verticalLimit = ocm.config.getDouble("old-player-knockback.knockback-vertical-limit") val extraHorizontal = ocm.config.getDouble("old-player-knockback.knockback-extra-horizontal") val extraVertical = ocm.config.getDouble("old-player-knockback.knockback-extra-vertical") val resistanceEnabled = ocm.config.getBoolean("old-player-knockback.enable-knockback-resistance") try { block() } finally { ocm.config.set("old-player-knockback.knockback-horizontal", horizontal) ocm.config.set("old-player-knockback.knockback-vertical", vertical) ocm.config.set("old-player-knockback.knockback-vertical-limit", verticalLimit) ocm.config.set("old-player-knockback.knockback-extra-horizontal", extraHorizontal) ocm.config.set("old-player-knockback.knockback-extra-vertical", extraVertical) ocm.config.set("old-player-knockback.enable-knockback-resistance", resistanceEnabled) module.reload() ModuleLoader.toggleModules() } } fun setModeset(player: Player, modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) } fun pendingKnockbackField(): java.lang.reflect.Field { val names = listOf("pendingKnockback", "playerKnockbackHashMap") for (name in names) { val f = runCatching { ModulePlayerKnockback::class.java.getDeclaredField(name) }.getOrNull() ?: continue f.isAccessible = true return f } error("No pending knockback field found on ModulePlayerKnockback (tried: $names)") } fun pendingKnockbackMap(): MutableMap { val field = pendingKnockbackField() @Suppress("UNCHECKED_CAST") return field.get(module) as MutableMap } fun getPendingVector(uuid: UUID): Vector? { val map = pendingKnockbackMap() val value = map[uuid] ?: return null return when (value) { is Vector -> value else -> { val vf = value.javaClass.getDeclaredField("velocity") vf.isAccessible = true vf.get(value) as? Vector } } } fun removePending(uuid: UUID) { pendingKnockbackMap().remove(uuid) } fun putPending(uuid: UUID, vector: Vector) { val fieldName = pendingKnockbackField().name if (fieldName == "playerKnockbackHashMap") { @Suppress("UNCHECKED_CAST") (pendingKnockbackMap() as MutableMap)[uuid] = vector return } val pendingClass = ModulePlayerKnockback::class.java.declaredClasses .firstOrNull { it.simpleName == "PendingKnockback" } ?: error("PendingKnockback inner class not found") val ctor = pendingClass.getDeclaredConstructor(Vector::class.java, Long::class.javaPrimitiveType) ctor.isAccessible = true val pending = ctor.newInstance(vector, Long.MAX_VALUE) pendingKnockbackMap()[uuid] = pending } fun damageEvent(): EntityDamageByEntityEvent { val event = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0) Bukkit.getPluginManager().callEvent(event) return event } fun velocityEvent(initial: Vector): PlayerVelocityEvent { val event = PlayerVelocityEvent(victim, initial) Bukkit.getPluginManager().callEvent(event) return event } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getServer().getWorld("world") val attackerLocation = Location(world, 0.0, 100.0, 0.0, 0f, 0f) val victimLocation = Location(world, 1.0, 100.0, 0.0, 0f, 0f) fakeAttacker = FakePlayer(testPlugin) fakeVictim = FakePlayer(testPlugin) fakeAttacker.spawn(attackerLocation) fakeVictim.spawn(victimLocation) attacker = checkNotNull(Bukkit.getPlayer(fakeAttacker.uuid)) victim = checkNotNull(Bukkit.getPlayer(fakeVictim.uuid)) attacker.isOp = true victim.isOp = true attacker.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) setModeset(attacker, "old") setModeset(victim, "old") } } afterSpec { runSync { fakeAttacker.removePlayer() fakeVictim.removePlayer() } } beforeTest { runSync { val world = Bukkit.getServer().getWorld("world") val attackerLocation = Location(world, 0.0, 100.0, 0.0, 0f, 0f) val victimLocation = Location(world, 1.0, 100.0, 0.0, 0f, 0f) attacker.teleport(attackerLocation) victim.teleport(victimLocation) attacker.isSprinting = false attacker.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) attacker.velocity = Vector(0, 0, 0) victim.velocity = Vector(0, 0, 0) victim.noDamageTicks = 0 victim.maximumNoDamageTicks = 0 victim.isInvulnerable = false setModeset(attacker, "old") setModeset(victim, "old") module.reload() } } context("Knockback vectors") { test("base knockback is applied on velocity event") { withConfig { ocm.config.set("old-player-knockback.knockback-horizontal", 0.4) ocm.config.set("old-player-knockback.knockback-vertical", 0.4) ocm.config.set("old-player-knockback.knockback-vertical-limit", 0.4) ocm.config.set("old-player-knockback.knockback-extra-horizontal", 0.5) ocm.config.set("old-player-knockback.knockback-extra-vertical", 0.1) ocm.config.set("old-player-knockback.enable-knockback-resistance", false) module.reload() damageEvent() val vector = getPendingVector(victim.uniqueId) ?: error("No knockback stored") vector.x shouldBe (0.4 plusOrMinus 0.0001) vector.y shouldBe (0.4 plusOrMinus 0.0001) vector.z shouldBe (0.0 plusOrMinus 0.0001) removePending(victim.uniqueId) } } test("sprint adds extra knockback") { withConfig { ocm.config.set("old-player-knockback.knockback-horizontal", 0.4) ocm.config.set("old-player-knockback.knockback-vertical", 0.4) ocm.config.set("old-player-knockback.knockback-vertical-limit", 0.4) ocm.config.set("old-player-knockback.knockback-extra-horizontal", 0.5) ocm.config.set("old-player-knockback.knockback-extra-vertical", 0.1) ocm.config.set("old-player-knockback.enable-knockback-resistance", false) module.reload() attacker.isSprinting = true attacker.teleport(attacker.location.apply { yaw = 0f }) val event = EntityDamageByEntityEvent( attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0 ) module.onEntityDamageEntity(event) val vector = getPendingVector(victim.uniqueId) ?: error("No knockback stored") vector.x shouldBe (0.4 plusOrMinus 0.0001) vector.y shouldBe (0.5 plusOrMinus 0.0001) vector.z shouldBe (0.5 plusOrMinus 0.0001) removePending(victim.uniqueId) } } test("velocity override only applies once") { withConfig { ocm.config.set("old-player-knockback.knockback-horizontal", 0.4) ocm.config.set("old-player-knockback.knockback-vertical", 0.4) ocm.config.set("old-player-knockback.knockback-vertical-limit", 0.4) ocm.config.set("old-player-knockback.knockback-extra-horizontal", 0.5) ocm.config.set("old-player-knockback.knockback-extra-vertical", 0.1) ocm.config.set("old-player-knockback.enable-knockback-resistance", false) module.reload() val expected = Vector(0.4, 0.4, 0.0) putPending(victim.uniqueId, expected) val first = velocityEvent(Vector(0, 0, 0)) first.velocity.x shouldBe (0.4 plusOrMinus 0.0001) val secondInitial = Vector(1.0, 2.0, 3.0) val second = velocityEvent(secondInitial) second.velocity.x shouldBe (1.0 plusOrMinus 0.0001) second.velocity.y shouldBe (2.0 plusOrMinus 0.0001) second.velocity.z shouldBe (3.0 plusOrMinus 0.0001) } } } context("Knockback resistance") { test("modifiers are removed when resistance disabled") { withConfig { ocm.config.set("old-player-knockback.enable-knockback-resistance", false) module.reload() val attributeType = XAttribute.KNOCKBACK_RESISTANCE.get() ?: return@withConfig val attribute = victim.getAttribute(attributeType) val modifier = AttributeModifier(UUID.randomUUID(), "test", 0.5, AttributeModifier.Operation.ADD_NUMBER) attribute?.addModifier(modifier) val event = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0) Bukkit.getPluginManager().callEvent(event) attribute?.modifiers?.contains(modifier) shouldBe false } } test("modifiers remain when resistance enabled and supported") { if (!Reflector.versionIsNewerOrEqualTo(1, 16, 0)) return@test withConfig { ocm.config.set("old-player-knockback.enable-knockback-resistance", true) module.reload() val attributeType = XAttribute.KNOCKBACK_RESISTANCE.get() ?: return@withConfig val attribute = victim.getAttribute(attributeType) val modifier = AttributeModifier(UUID.randomUUID(), "test", 0.5, AttributeModifier.Operation.ADD_NUMBER) attribute?.addModifier(modifier) val event = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 4.0) Bukkit.getPluginManager().callEvent(event) attribute?.modifiers?.contains(modifier) shouldBe true } } test("enabled resistance scales horizontal knockback") { if (!Reflector.versionIsNewerOrEqualTo(1, 16, 0)) return@test withConfig { ocm.config.set("old-player-knockback.knockback-horizontal", 0.4) ocm.config.set("old-player-knockback.knockback-vertical", 0.4) ocm.config.set("old-player-knockback.knockback-vertical-limit", 0.4) ocm.config.set("old-player-knockback.knockback-extra-horizontal", 0.5) ocm.config.set("old-player-knockback.knockback-extra-vertical", 0.1) ocm.config.set("old-player-knockback.enable-knockback-resistance", true) module.reload() val attributeType = XAttribute.KNOCKBACK_RESISTANCE.get() ?: return@withConfig val attribute = victim.getAttribute(attributeType) ?: return@withConfig val originalBase = attribute.baseValue attribute.baseValue = 0.5 try { val event = damageEvent() event.isCancelled shouldBe false val vector = getPendingVector(victim.uniqueId) ?: error("No knockback stored") val expectedHorizontal = 0.4 * (1 - attribute.value) vector.x shouldBe (expectedHorizontal plusOrMinus 0.0001) vector.y shouldBe (0.4 plusOrMinus 0.0001) removePending(victim.uniqueId) } finally { attribute.baseValue = originalBase } } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/PlayerRegenIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModulePlayerRegen import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.entity.Player import org.bukkit.event.entity.EntityRegainHealthEvent import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class PlayerRegenIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader.getModules().filterIsInstance().firstOrNull() ?: error("ModulePlayerRegen not registered") lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> T): T { return if (Bukkit.isPrimaryThread()) action() else Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } fun setModeset(player: Player, modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) ModuleLoader.toggleModules() } suspend fun withConfig(intervalMs: Long, amount: Int, exhaustion: Double, block: suspend () -> Unit) { val oldInterval = ocm.config.getLong("old-player-regen.interval") val oldAmount = ocm.config.getInt("old-player-regen.amount") val oldExhaustion = ocm.config.getDouble("old-player-regen.exhaustion") try { runSync { ocm.config.set("old-player-regen.interval", intervalMs) ocm.config.set("old-player-regen.amount", amount) ocm.config.set("old-player-regen.exhaustion", exhaustion) module.reload() ModuleLoader.toggleModules() } block() } finally { runSync { ocm.config.set("old-player-regen.interval", oldInterval) ocm.config.set("old-player-regen.amount", oldAmount) ocm.config.set("old-player-regen.exhaustion", oldExhaustion) module.reload() ModuleLoader.toggleModules() } } } fun createRegainEvent(player: Player, reason: EntityRegainHealthEvent.RegainReason, amount: Double): EntityRegainHealthEvent { val ctors = EntityRegainHealthEvent::class.java.constructors for (ctor in ctors) { val paramTypes = ctor.parameterTypes val args = arrayOfNulls(paramTypes.size) var ok = true for (i in paramTypes.indices) { val t = paramTypes[i] args[i] = when { org.bukkit.entity.Entity::class.java.isAssignableFrom(t) -> player t == java.lang.Double.TYPE || t == Double::class.java -> amount EntityRegainHealthEvent.RegainReason::class.java.isAssignableFrom(t) -> reason else -> null } if (args[i] == null && t.isPrimitive) { ok = false break } } if (!ok) continue try { @Suppress("UNCHECKED_CAST") return ctor.newInstance(*args) as EntityRegainHealthEvent } catch (_: Throwable) { // Try next } } error("No compatible EntityRegainHealthEvent constructor found for this server version") } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getWorld("world") ?: error("world not loaded") val location = Location(world, 0.0, 120.0, 0.0, 0f, 0f) fakePlayer = FakePlayer(testPlugin) fakePlayer.spawn(location) player = Bukkit.getPlayer(fakePlayer.uuid) ?: error("Player not found") player.isOp = true setModeset(player, "old") } } afterSpec { runSync { fakePlayer.removePlayer() } } beforeTest { runSync { setModeset(player, "old") player.health = 20.0 player.exhaustion = 0f player.saturation = 0f // Ensure per-player state from previous tests does not leak (healTimes is keyed by UUID). runCatching { val names = listOf("lastHealTick", "healTimes") val f = names.asSequence() .mapNotNull { name -> runCatching { ModulePlayerRegen::class.java.getDeclaredField(name) }.getOrNull() } .firstOrNull() if (f != null) { f.isAccessible = true @Suppress("UNCHECKED_CAST") (f.get(module) as? MutableMap)?.clear() } } } } test("SATIATED regen is cancelled and replaced with configured heal + exhaustion") { withConfig(intervalMs = 0, amount = 2, exhaustion = 3.0) { runSync { player.health = 10.0 player.exhaustion = 1.0f } val event = runSync { createRegainEvent(player, EntityRegainHealthEvent.RegainReason.SATIATED, 1.0) } runSync { module.onRegen(event) event.isCancelled shouldBe true player.health shouldBe (12.0 plusOrMinus 1e-9) // Simulate vanilla modifying exhaustion despite the cancellation; OCM applies its own value next tick. player.exhaustion = 2.0f } delay(2 * 50L) runSync { player.exhaustion.toDouble() shouldBe (4.0 plusOrMinus 0.0001) // previous(1.0) + config(3.0) } } } test("heal is skipped when within the configured interval") { withConfig(intervalMs = 60_000, amount = 2, exhaustion = 3.0) { runSync { player.health = 10.0 player.exhaustion = 1.0f } val first = runSync { createRegainEvent(player, EntityRegainHealthEvent.RegainReason.SATIATED, 1.0) } runSync { module.onRegen(first) player.health shouldBe (12.0 plusOrMinus 1e-9) } // Simulate immediate damage, then attempt to heal again within the interval. runSync { player.health = 10.0 player.exhaustion = 1.0f } val second = runSync { createRegainEvent(player, EntityRegainHealthEvent.RegainReason.SATIATED, 1.0) } runSync { module.onRegen(second) second.isCancelled shouldBe true player.health shouldBe (10.0 plusOrMinus 1e-9) // Simulate vanilla exhaustion change; the module should restore to previous exhaustion next tick. player.exhaustion = 3.5f } delay(2 * 50L) runSync { player.exhaustion.toDouble() shouldBe (1.0 plusOrMinus 0.0001) } } } test("non-SATIATED regain reasons are not modified") { val nonSatiated = EntityRegainHealthEvent.RegainReason.values().firstOrNull { it != EntityRegainHealthEvent.RegainReason.SATIATED } ?: error("No non-SATIATED regain reason available") withConfig(intervalMs = 0, amount = 100, exhaustion = 3.0) { runSync { player.health = 10.0 player.exhaustion = 1.0f } val event = runSync { createRegainEvent(player, nonSatiated, 5.0) } runSync { module.onRegen(event) event.isCancelled shouldBe false player.health shouldBe (10.0 plusOrMinus 1e-9) } } } test("healing is clamped to max health") { withConfig(intervalMs = 0, amount = 100, exhaustion = 3.0) { runSync { player.health = 19.5 } val event = runSync { createRegainEvent(player, EntityRegainHealthEvent.RegainReason.SATIATED, 1.0) } runSync { module.onRegen(event) player.health shouldBe (20.0 plusOrMinus 1e-9) } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/SpigotFunctionChooserIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.assertions.throwables.shouldThrow import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.StringSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser import java.util.concurrent.atomic.AtomicInteger @OptIn(ExperimentalKotest::class) class SpigotFunctionChooserIntegrationTest : StringSpec({ "compatibility failures choose fallback and stay cached" { val compatibilityFailures = listOf( NoSuchMethodError("missing API method"), NoClassDefFoundError("missing API class"), AbstractMethodError("abstract API method"), IncompatibleClassChangeError("binary incompatibility"), CompatibilityUnsupportedOperationException("compatibility fallback approved"), ) compatibilityFailures.forEach { throwable -> val apiCalls = AtomicInteger(0) val fallbackCalls = AtomicInteger(0) val chooser = SpigotFunctionChooser.apiCompatCall( { _, _ -> apiCalls.incrementAndGet() throw throwable }, { _, _ -> fallbackCalls.incrementAndGet() "fallback" }, ) chooser.apply("target", Any()) shouldBe "fallback" chooser.apply("target", Any()) shouldBe "fallback" apiCalls.get() shouldBe 1 fallbackCalls.get() shouldBe 2 } } "ordinary logic failures are surfaced instead of choosing fallback" { val fallbackCalls = AtomicInteger(0) val chooser = SpigotFunctionChooser.apiCompatCall( { _, _ -> throw IllegalStateException("business logic failure") }, { _, _ -> fallbackCalls.incrementAndGet() "fallback" }, ) shouldThrow { chooser.apply("target", Any()) } fallbackCalls.get() shouldBe 0 } "null pointer failures are surfaced instead of choosing fallback" { val fallbackCalls = AtomicInteger(0) val chooser = SpigotFunctionChooser.apiCompatCall( { _, _ -> throw NullPointerException("unexpected null") }, { _, _ -> fallbackCalls.incrementAndGet() "fallback" }, ) shouldThrow { chooser.apply("target", Any()) } fallbackCalls.get() shouldBe 0 } "generic unsupported operation with incompatible wording is surfaced" { val fallbackCalls = AtomicInteger(0) val chooser = SpigotFunctionChooser.apiCompatCall( { _, _ -> throw UnsupportedOperationException("incompatible state for this action") }, { _, _ -> fallbackCalls.incrementAndGet() "fallback" }, ) shouldThrow { chooser.apply("target", Any()) } fallbackCalls.get() shouldBe 0 } }) private class CompatibilityUnsupportedOperationException( message: String, ) : UnsupportedOperationException(message) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/SwordBlockingIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.StringSpec import io.kotest.core.test.TestScope import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleSwordBlocking import kernitus.plugin.OldCombatMechanics.utilities.Config import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.GameMode import org.bukkit.Location import org.bukkit.Material import org.bukkit.block.BlockFace import org.bukkit.entity.Entity import org.bukkit.entity.EntityType import org.bukkit.entity.Item import org.bukkit.entity.Player import org.bukkit.event.block.Action import org.bukkit.event.player.PlayerDropItemEvent import org.bukkit.event.player.PlayerInteractAtEntityEvent import org.bukkit.event.player.PlayerInteractEntityEvent import org.bukkit.event.player.PlayerInteractEvent import org.bukkit.event.player.PlayerItemHeldEvent import org.bukkit.inventory.EquipmentSlot import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import org.bukkit.util.Vector import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class SwordBlockingIntegrationTest : StringSpec({ val plugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) val module = ModuleLoader .getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleSwordBlocking not registered") extension(MainThreadDispatcherExtension(plugin)) lateinit var player: Player lateinit var fakePlayer: FakePlayer fun runSync(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod( plugin, Callable { action() }, ).get() } fun preparePlayer() { println("Preparing player") val world = Bukkit.getServer().getWorld("world") val location = Location(world, 0.0, 100.0, 0.0) fakePlayer = FakePlayer(plugin) fakePlayer.spawn(location) player = checkNotNull(Bukkit.getPlayer(fakePlayer.uuid)) } beforeSpec { Bukkit.getScheduler().runTask( plugin, Runnable { plugin.logger.info("Running before all") preparePlayer() player.gameMode = GameMode.SURVIVAL player.maximumNoDamageTicks = 20 player.noDamageTicks = 0 // remove spawn invulnerability player.isInvulnerable = false }, ) } fun rightClickWithMainHand() = runSync { val event = PlayerInteractEvent( player, Action.RIGHT_CLICK_AIR, player.inventory.itemInMainHand, null, BlockFace.SELF, EquipmentSlot.HAND, ) Bukkit.getPluginManager().callEvent(event) } fun rightClickEntity( target: Entity, hand: EquipmentSlot, ) = runSync { Bukkit.getPluginManager().callEvent(PlayerInteractEntityEvent(player, target, hand)) } fun rightClickEntityAt( target: Entity, hand: EquipmentSlot, ) = runSync { Bukkit.getPluginManager().callEvent(PlayerInteractAtEntityEvent(player, target, Vector(0.0, 1.0, 0.0), hand)) } fun spawnEntityTarget(): Entity = runSync { player.world.spawnEntity(player.location.clone().add(1.0, 0.0, 0.0), EntityType.VILLAGER) } fun forceRestoreViaHotbarChange() = runSync { val previous = player.inventory.heldItemSlot val next = (previous + 1) % 9 Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, previous, next)) player.inventory.heldItemSlot = previous } fun paperConsumablePathAvailable(): Boolean = try { Class.forName("io.papermc.paper.datacomponent.DataComponentTypes") val supportedField = ModuleSwordBlocking::class.java.getDeclaredField("paperSupported") supportedField.isAccessible = true val adapterField = ModuleSwordBlocking::class.java.getDeclaredField("paperAdapter") adapterField.isAccessible = true supportedField.getBoolean(module) && adapterField.get(module) != null } catch (_: Throwable) { false } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } suspend fun TestScope.withPaperAnimationEnabled( enabled: Boolean, block: suspend TestScope.() -> Unit, ) { val original = runSync { ocm.config.get("sword-blocking.paper-animation") } runSync { ocm.config.set("sword-blocking.paper-animation", enabled) ocm.saveConfig() Config.reload() } try { block() } finally { runSync { ocm.config.set("sword-blocking.paper-animation", original) ocm.saveConfig() Config.reload() } } } suspend fun TestScope.withUsePermission( required: Boolean, block: suspend TestScope.() -> Unit, ) { val original = runSync { ocm.config.getBoolean("sword-blocking.use-permission") } runSync { ocm.config.set("sword-blocking.use-permission", required) module.reload() ModuleLoader.toggleModules() } try { block() } finally { runSync { ocm.config.set("sword-blocking.use-permission", original) module.reload() ModuleLoader.toggleModules() } } } beforeTest { runSync { player.inventory.clear() player.noDamageTicks = 0 player.maximumNoDamageTicks = 20 player.isInvulnerable = false } } afterTest { forceRestoreViaHotbarChange() runSync { player.inventory.clear() } } afterSpec { plugin.logger.info("Running after all") Bukkit.getScheduler().runTask( plugin, Runnable { fakePlayer.removePlayer() }, ) } "adds blocking when right-clicking with a sword (shield on legacy, consumable on Paper)" { runSync { player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickWithMainHand() delayTicks(1) runSync { // Legacy path: module injects a shield (actual "blocking" state is client-driven). // Paper path: offhand remains intact and a consumable-based use animation can surface as "hand raised". (player.inventory.itemInOffHand.type == Material.SHIELD || player.isBlocking || player.isHandRaised) shouldBe true // Legacy path injects shield; paper path keeps offhand intact setOf(Material.SHIELD, Material.AIR).contains(player.inventory.itemInOffHand.type) shouldBe true } } "paper-animation config false forces legacy shield fallback on Paper" { if (!paperConsumablePathAvailable()) { println("Skipping: Paper consumable component path unavailable") } else { withPaperAnimationEnabled(enabled = false) { runSync { player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickWithMainHand() delayTicks(1) runSync { player.inventory.itemInOffHand.type shouldBe Material.SHIELD } } } } "does not start blocking without a sword in the main hand" { runSync { player.inventory.setItemInMainHand(ItemStack(Material.STICK)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickWithMainHand() runSync { player.isBlocking shouldBe false player.inventory.itemInOffHand.type shouldBe Material.AIR } } "starts blocking on main-hand entity right-click (shield on legacy, consumable on Paper)" { val target = spawnEntityTarget() try { runSync { player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickEntity(target, EquipmentSlot.HAND) delayTicks(1) runSync { (player.inventory.itemInOffHand.type == Material.SHIELD || player.isBlocking || player.isHandRaised) shouldBe true setOf(Material.SHIELD, Material.AIR).contains(player.inventory.itemInOffHand.type) shouldBe true } } finally { runSync { target.remove() } } } "does not start blocking on offhand entity right-click" { val target = spawnEntityTarget() try { runSync { player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickEntity(target, EquipmentSlot.OFF_HAND) delayTicks(1) runSync { player.isBlocking shouldBe false player.inventory.itemInOffHand.type shouldBe Material.AIR } } finally { runSync { target.remove() } } } "entity interact plus interact-at should not duplicate side effects" { val originalOffhand = ItemStack(Material.APPLE) val target = spawnEntityTarget() try { runSync { player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) player.inventory.setItemInOffHand(originalOffhand.clone()) } rightClickEntity(target, EquipmentSlot.HAND) rightClickEntityAt(target, EquipmentSlot.HAND) delayTicks(1) runSync { (player.inventory.itemInOffHand.type == Material.SHIELD || player.isBlocking || player.isHandRaised) shouldBe true if (player.inventory.itemInOffHand.type == Material.SHIELD) { forceRestoreViaHotbarChange() } player.inventory.itemInOffHand.type shouldBe originalOffhand.type } } finally { runSync { target.remove() } } } "restores the previous offhand item after a hotbar change (or leaves untouched on Paper path)" { val originalOffhand = ItemStack(Material.APPLE) runSync { player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) player.inventory.setItemInOffHand(originalOffhand.clone()) } rightClickWithMainHand() runSync { if (player.inventory.itemInOffHand.type == Material.SHIELD) { forceRestoreViaHotbarChange() player.isBlocking shouldBe false player.inventory.itemInOffHand.type shouldBe originalOffhand.type } else { // Paper path: offhand never changed player.inventory.itemInOffHand.type shouldBe originalOffhand.type } } } "cancels dropping the temporary shield and restores the stored item (legacy path only)" { runSync { player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickWithMainHand() val dropped: Item = runSync { player.world.dropItem(player.location, ItemStack(Material.SHIELD)) } runSync { Bukkit.getPluginManager().callEvent(PlayerDropItemEvent(player, dropped)) } runSync { if (player.inventory.itemInOffHand.type == Material.SHIELD) { player.inventory.itemInOffHand.type shouldBe Material.AIR player.isBlocking shouldBe false } else { // Paper path: no injected shield; ensure we did not cancel normal state player.inventory.itemInOffHand.type shouldBe Material.AIR } } runSync { dropped.remove() } } "respects permission requirement when enabled" { withUsePermission(required = true) { runSync { player.isOp = false player.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) player.inventory.setItemInOffHand(ItemStack(Material.AIR)) } rightClickWithMainHand() delayTicks(1) runSync { player.isBlocking shouldBe false player.inventory.itemInOffHand.type shouldBe Material.AIR } runSync { player.addAttachment(plugin, "oldcombatmechanics.swordblock", true) } rightClickWithMainHand() delayTicks(1) runSync { // Legacy path injects a shield and sets isBlocking; Paper path keeps offhand intact and uses a // consumable-based use animation which can surface as "hand raised". (player.inventory.itemInOffHand.type == Material.SHIELD || player.isBlocking || player.isHandRaised) shouldBe true setOf(Material.SHIELD, Material.AIR).contains(player.inventory.itemInOffHand.type) shouldBe true } } } "does not replace an existing real shield in offhand" { val namedShield = ItemStack(Material.SHIELD).apply { val meta = itemMeta meta?.setDisplayName("Real Shield") itemMeta = meta } runSync { player.inventory.setItemInMainHand(ItemStack(Material.IRON_SWORD)) player.inventory.setItemInOffHand(namedShield) } rightClickWithMainHand() runSync { val meta = player.inventory.itemInOffHand.itemMeta meta?.displayName shouldBe "Real Shield" player.inventory.itemInOffHand.type shouldBe Material.SHIELD } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/SwordSweepIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.module.ModuleSwordSweep import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class SwordSweepIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val module = ModuleLoader.getModules() .filterIsInstance() .firstOrNull() ?: error("ModuleSwordSweep not registered") lateinit var attacker: Player lateinit var victim: Player lateinit var fakeAttacker: FakePlayer lateinit var fakeVictim: FakePlayer fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() null }).get() } } fun setModeset(player: Player, modeset: String) { val playerData = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, modeset) kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData(player.uniqueId, playerData) } extensions(MainThreadDispatcherExtension(testPlugin)) beforeSpec { runSync { val world = Bukkit.getServer().getWorld("world") val attackerLocation = Location(world, 0.0, 100.0, 0.0) val victimLocation = Location(world, 1.0, 100.0, 0.0) fakeAttacker = FakePlayer(testPlugin) fakeVictim = FakePlayer(testPlugin) fakeAttacker.spawn(attackerLocation) fakeVictim.spawn(victimLocation) attacker = checkNotNull(Bukkit.getPlayer(fakeAttacker.uuid)) victim = checkNotNull(Bukkit.getPlayer(fakeVictim.uuid)) attacker.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) setModeset(attacker, "old") setModeset(victim, "old") module.reload() } } afterSpec { runSync { fakeAttacker.removePlayer() fakeVictim.removePlayer() } } beforeTest { runSync { attacker.inventory.setItemInMainHand(ItemStack(Material.DIAMOND_SWORD)) setModeset(attacker, "old") setModeset(victim, "old") module.reload() } } context("Sweep attack cancellation") { test("sweep attack is cancelled when enabled") { val sweepCause = EntityDamageEvent.DamageCause.values() .firstOrNull { it.name == "ENTITY_SWEEP_ATTACK" } if (sweepCause != null) { val event = EntityDamageByEntityEvent(attacker, victim, sweepCause, 1.0) Bukkit.getPluginManager().callEvent(event) event.isCancelled shouldBe true } else { // Legacy (1.9): simulate sweep detection fallback (no dedicated cause) val baseDamage = (NewWeaponDamage.getDamageOrNull(attacker.inventory.itemInMainHand.type) ?: 1.0f).toDouble() val sweepDamage = 1.0 // matches ModuleSwordSweep fallback for level 0 // First, register the attacker location so the module can recognise the next hit as sweep val priming = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, baseDamage + 1) module.onEntityDamaged(priming) val sweepEvent = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, sweepDamage) module.onEntityDamaged(sweepEvent) sweepEvent.isCancelled shouldBe true } } test("non-sweep attack is not cancelled") { val event = EntityDamageByEntityEvent( attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 1.0 ) Bukkit.getPluginManager().callEvent(event) event.isCancelled shouldBe false } test("disabled module does not cancel sweep") { setModeset(attacker, "new") val sweepCause = EntityDamageEvent.DamageCause.values() .firstOrNull { it.name == "ENTITY_SWEEP_ATTACK" } if (sweepCause != null) { val event = EntityDamageByEntityEvent(attacker, victim, sweepCause, 1.0) module.onEntityDamaged(event) event.isCancelled shouldBe false } else { val baseDamage = (NewWeaponDamage.getDamageOrNull(attacker.inventory.itemInMainHand.type) ?: 1.0f).toDouble() val sweepDamage = 1.0 val priming = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, baseDamage + 1) module.onEntityDamaged(priming) val sweepEvent = EntityDamageByEntityEvent(attacker, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, sweepDamage) module.onEntityDamaged(sweepEvent) sweepEvent.isCancelled shouldBe false } } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/Tally.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics class Tally { var passed: Int = 0 private set var failed: Int = 0 private set fun passed() { passed++ } fun failed() { failed++ } val total: Int get() = passed + failed } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/TestResultWriter.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import org.bukkit.Bukkit import org.bukkit.plugin.java.JavaPlugin import java.io.File import java.util.logging.Level object TestResultWriter { @JvmStatic fun writeAndShutdown(plugin: JavaPlugin, success: Boolean, error: Throwable? = null) { try { val resultFile = File(plugin.dataFolder, "test-results.txt") resultFile.parentFile.mkdirs() resultFile.writeText(if (success) "PASS" else "FAIL") plugin.logger.info("Test result written to ${resultFile.absolutePath}") } catch (e: Exception) { plugin.logger.log(Level.SEVERE, "Failed to write test results file.", e) } if (error != null) { plugin.logger.log(Level.SEVERE, "Integration tests failed.", error) } Bukkit.shutdown() } @JvmStatic fun writeFailureSummary(plugin: JavaPlugin, lines: List) { try { val file = File(plugin.dataFolder, "test-failures.txt") file.parentFile.mkdirs() file.writeText(lines.joinToString(separator = "\n", postfix = if (lines.isEmpty()) "" else "\n")) } catch (e: Exception) { plugin.logger.log(Level.SEVERE, "Failed to write test failures file.", e) } } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/TesterUtils.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import kernitus.plugin.OldCombatMechanics.utilities.Messenger.send import org.bukkit.command.CommandSender import org.bukkit.entity.LivingEntity import org.bukkit.potion.PotionEffect import org.bukkit.potion.PotionEffectType object TesterUtils { /** * Checks whether the two values are equal, prints the result and updates the tally * * @param a The expected value * @param b The actual value * @param tally The tally to update the result of the test with * @param testName The name of the test being run * @param senders The command senders to message with the result of the test */ fun assertEquals(a: Float, b: Float, tally: Tally, testName: String, vararg senders: CommandSender) { // Due to cooldown effects, numbers can be very close (e.g. 1.0000000149011612 == 1.0) // These are equivalent when using floats, which is what the server is using anyway if (a == b) { tally.passed() for (sender in senders) send( sender, "&aPASSED &f$testName [E: $a / A: $b]" ) } else { tally.failed() for (sender in senders) send( sender, "&cFAILED &f$testName [E: $a / A: $b]" ) } } /** * Cross-version accessor for a specific potion effect. Pre-1.12 servers lack * LivingEntity#getPotionEffect, so we fall back to scanning active effects. */ fun LivingEntity.getPotionEffectCompat(type: PotionEffectType): PotionEffect? { // Prefer reflection to avoid linkage errors on legacy servers. val method = javaClass.methods.firstOrNull { m -> m.name == "getPotionEffect" && m.parameterTypes.size == 1 && m.parameterTypes[0] == PotionEffectType::class.java } return runCatching { method?.invoke(this, type) as PotionEffect? }.getOrNull() ?: activePotionEffects.firstOrNull { it.type == type } } } ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/ToolDamageTooltipIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import io.kotest.core.test.TestScope import io.kotest.matchers.doubles.plusOrMinus import io.kotest.matchers.shouldBe import kernitus.plugin.OldCombatMechanics.utilities.Config import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.ChatColor import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.player.PlayerItemHeldEvent import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.event.player.PlayerSwapHandItemsEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.util.concurrent.Callable @OptIn(ExperimentalKotest::class) class ToolDamageTooltipIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) val ocm = JavaPlugin.getPlugin(OCMMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod( testPlugin, Callable { action() null }, ).get() } } fun runSyncAndGet(action: () -> T): T = if (Bukkit.isPrimaryThread()) { action() } else { Bukkit.getScheduler().callSyncMethod(testPlugin, Callable { action() }).get() } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } val lorePrefix = "OCM Damage:" fun stripColour(line: String): String = ChatColor.stripColor(line) ?: line fun findOcmLines(item: ItemStack): List { val lore = item.itemMeta?.lore ?: emptyList() return lore.filter { stripColour(it).startsWith(lorePrefix) } } fun parseFirstDamage(item: ItemStack): Double? { val line = findOcmLines(item).firstOrNull() ?: return null val stripped = stripColour(line) val match = Regex("(-?\\d+(?:\\.\\d+)?)").find(stripped) ?: return null return match.value.toDoubleOrNull() } fun setLore( item: ItemStack, lines: List?, ) { val meta = item.itemMeta ?: return meta.lore = lines item.itemMeta = meta } data class SpawnedPlayer( val fake: FakePlayer, val player: Player, ) fun spawnFake(location: Location): SpawnedPlayer { lateinit var fake: FakePlayer lateinit var player: Player runSync { fake = FakePlayer(testPlugin) fake.spawn(location) player = checkNotNull(Bukkit.getPlayer(fake.uuid)) player.inventory.clear() player.isInvulnerable = false player.activePotionEffects.forEach { player.removePotionEffect(it.type) } val data = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage .getPlayerData(player.uniqueId) data.setModesetForWorld(player.world.uid, "old") kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage .setPlayerData(player.uniqueId, data) } return SpawnedPlayer(fake, player) } fun cleanup(vararg players: SpawnedPlayer) { runSync { players.forEach { it.fake.removePlayer() } } } suspend fun TestScope.withConfig( weaponMaterialKey: String, weaponDamage: Double, block: suspend TestScope.() -> Unit, ) { val disabledModules = ocm.config.getStringList("disabled_modules") val modesetsSection = ocm.config.getConfigurationSection("modesets") ?: error("Missing 'modesets' section in config") val modesetSnapshot = modesetsSection.getKeys(false).associateWith { key -> ocm.config.getStringList("modesets.$key") } val damagesSnapshot = ocm.config .getConfigurationSection("old-tool-damage.damages") ?.getValues(false) ?: emptyMap() val tooltipEnabledSnapshot = ocm.config.get("old-tool-damage.tooltip.enabled") val tooltipPrefixSnapshot = ocm.config.get("old-tool-damage.tooltip.prefix") fun reloadAll() { ocm.saveConfig() Config.reload() WeaponDamages.initialise(ocm) ModuleLoader.toggleModules() } try { ocm.config.set("old-tool-damage.damages.$weaponMaterialKey", weaponDamage) ocm.config.set("old-tool-damage.tooltip.enabled", true) ocm.config.set("old-tool-damage.tooltip.prefix", lorePrefix) ocm.config.set("disabled_modules", disabledModules.filterNot { it == "old-tool-damage" }) val oldModeset = ocm.config.getStringList("modesets.old").toMutableList() if (!oldModeset.contains("old-tool-damage")) { oldModeset.add("old-tool-damage") } ocm.config.set("modesets.old", oldModeset) reloadAll() block() } finally { ocm.config.set("disabled_modules", disabledModules) modesetSnapshot.forEach { (key, list) -> ocm.config.set("modesets.$key", list) } ocm.config.set("old-tool-damage.damages", null) damagesSnapshot.forEach { (k, v) -> ocm.config.set("old-tool-damage.damages.$k", v) } ocm.config.set("old-tool-damage.tooltip.enabled", tooltipEnabledSnapshot) ocm.config.set("old-tool-damage.tooltip.prefix", tooltipPrefixSnapshot) reloadAll() } } fun fireJoin(player: Player) { Bukkit.getPluginManager().callEvent(PlayerJoinEvent(player, "test")) } fun switchHotbar( player: Player, from: Int, to: Int, ) { player.inventory.heldItemSlot = to Bukkit.getPluginManager().callEvent(PlayerItemHeldEvent(player, from, to)) } test("adds a tooltip lore line for configured vanilla weapon damage") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) runSync { p.player.inventory.setItem(0, sword) p.player.inventory.setItem(1, ItemStack(Material.STICK)) p.player.inventory.heldItemSlot = 1 } runSync { switchHotbar(p.player, from = 1, to = 0) } val held = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } val loreLines = findOcmLines(held) loreLines.size shouldBe 1 parseFirstDamage(held) shouldBe (7.0 plusOrMinus 0.01) cleanup(p) } } test("does not duplicate the tooltip lore line when applied repeatedly") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) runSync { p.player.inventory.setItemInMainHand(sword) } runSync { fireJoin(p.player) fireJoin(p.player) } val held = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } val loreLines = findOcmLines(held) loreLines.size shouldBe 1 cleanup(p) } } test("preserves existing lore when adding the tooltip line") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) runSync { setLore(sword, listOf("OtherPlugin: Example")) p.player.inventory.setItemInMainHand(sword) fireJoin(p.player) } val held = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } val lore = held.itemMeta?.lore ?: emptyList() lore.any { stripColour(it) == "OtherPlugin: Example" } shouldBe true findOcmLines(held).size shouldBe 1 cleanup(p) } } test("updates tooltip damage after config reload") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) runSync { p.player.inventory.setItemInMainHand(sword) fireJoin(p.player) } runSyncAndGet { parseFirstDamage(p.player.inventory.itemInMainHand) } shouldBe (7.0 plusOrMinus 0.01) runSync { ocm.config.set("old-tool-damage.damages.DIAMOND_SWORD", 9.0) ocm.saveConfig() Config.reload() WeaponDamages.initialise(ocm) ModuleLoader.toggleModules() fireJoin(p.player) } val held = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } findOcmLines(held).size shouldBe 1 parseFirstDamage(held) shouldBe (9.0 plusOrMinus 0.01) cleanup(p) } } test("cleans the tooltip lore line when the module is disabled") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) runSync { p.player.inventory.setItem(0, sword) p.player.inventory.setItem(1, ItemStack(Material.STICK)) p.player.inventory.heldItemSlot = 1 switchHotbar(p.player, from = 1, to = 0) } runSyncAndGet { val slot0 = p.player.inventory.getItem(0) ?: ItemStack(Material.AIR) findOcmLines(slot0).size } shouldBe 1 runSync { val data = kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage .getPlayerData(p.player.uniqueId) data.setModesetForWorld(p.player.world.uid, "new") kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage .setPlayerData(p.player.uniqueId, data) switchHotbar(p.player, from = 0, to = 1) // should clean the old hand } delayTicks(1) runSyncAndGet { val slot0 = p.player.inventory.getItem(0) ?: ItemStack(Material.AIR) findOcmLines(slot0).size } shouldBe 0 cleanup(p) } } test("does not add a tooltip lore line for non-weapons") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val stick = ItemStack(Material.STICK) runSync { p.player.inventory.setItemInMainHand(stick) fireJoin(p.player) } findOcmLines(stick).size shouldBe 0 cleanup(p) } } test("swap hand items applies tooltip to new main hand and keeps offhand clean") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) val stick = ItemStack(Material.STICK) runSync { p.player.inventory.setItemInMainHand(stick) p.player.inventory.setItemInOffHand(sword) val swap = PlayerSwapHandItemsEvent(p.player, stick, sword) Bukkit.getPluginManager().callEvent(swap) } findOcmLines(sword).size shouldBe 1 findOcmLines(stick).size shouldBe 0 cleanup(p) } } test("swap hand finalisation keeps tooltip only on new main-hand weapon") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) runSync { p.player.inventory.setItemInMainHand(ItemStack(Material.STICK)) p.player.inventory.setItemInOffHand(ItemStack(Material.DIAMOND_SWORD)) val swap = PlayerSwapHandItemsEvent( p.player, p.player.inventory.itemInMainHand, p.player.inventory.itemInOffHand, ) Bukkit.getPluginManager().callEvent(swap) val newMainHand = swap.offHandItem?.clone() ?: ItemStack(Material.AIR) val newOffHand = swap.mainHandItem?.clone() ?: ItemStack(Material.AIR) p.player.inventory.setItemInMainHand(newMainHand) p.player.inventory.setItemInOffHand(newOffHand) } val mainHand = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } val offHand = runSyncAndGet { p.player.inventory.itemInOffHand .clone() } mainHand.type shouldBe Material.DIAMOND_SWORD offHand.type shouldBe Material.STICK findOcmLines(mainHand).size shouldBe 1 findOcmLines(offHand).size shouldBe 0 cleanup(p) } } test("plays nicely with a lore-rewriting plugin (other lore preserved, no duplication)") { withConfig(weaponMaterialKey = "DIAMOND_SWORD", weaponDamage = 7.0) { val world = checkNotNull(Bukkit.getWorld("world")) val p = spawnFake(Location(world, 0.0, 100.0, 0.0)) val sword = ItemStack(Material.DIAMOND_SWORD) val otherPlugin = object : Listener { @EventHandler(priority = EventPriority.LOWEST) fun onJoin(event: PlayerJoinEvent) { if (event.player != p.player) return val item = event.player.inventory.itemInMainHand if (item.type != Material.DIAMOND_SWORD) return setLore(item, listOf("OtherPlugin: Rewritten")) } @EventHandler(priority = EventPriority.LOWEST) fun onHeld(event: PlayerItemHeldEvent) { if (event.player != p.player) return val item = event.player.inventory.itemInMainHand if (item.type != Material.DIAMOND_SWORD) return setLore(item, listOf("OtherPlugin: Rewritten")) } } runSync { Bukkit.getPluginManager().registerEvents(otherPlugin, testPlugin) p.player.inventory.setItemInMainHand(sword) fireJoin(p.player) fireJoin(p.player) HandlerList.unregisterAll(otherPlugin) } val held = runSyncAndGet { p.player.inventory.itemInMainHand .clone() } val lore = held.itemMeta?.lore ?: emptyList() lore.any { stripColour(it) == "OtherPlugin: Rewritten" } shouldBe true findOcmLines(held).size shouldBe 1 cleanup(p) } } }) ================================================ FILE: src/integrationTest/kotlin/kernitus/plugin/OldCombatMechanics/WeaponDurabilityIntegrationTest.kt ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics import io.kotest.common.ExperimentalKotest import io.kotest.core.spec.style.FunSpec import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.getPlayerData import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage.setPlayerData import kotlinx.coroutines.delay import org.bukkit.Bukkit import org.bukkit.Location import org.bukkit.Material import org.bukkit.entity.LivingEntity import org.bukkit.entity.Player import org.bukkit.event.EventHandler import org.bukkit.event.EventPriority import org.bukkit.event.HandlerList import org.bukkit.event.Listener import org.bukkit.event.entity.EntityDamageByEntityEvent import org.bukkit.event.entity.EntityDamageEvent import org.bukkit.event.player.PlayerItemDamageEvent import org.bukkit.inventory.ItemStack import org.bukkit.plugin.java.JavaPlugin import java.io.File import java.util.concurrent.Callable import java.util.concurrent.atomic.AtomicInteger @OptIn(ExperimentalKotest::class) class WeaponDurabilityIntegrationTest : FunSpec({ val testPlugin = JavaPlugin.getPlugin(OCMTestMain::class.java) extensions(MainThreadDispatcherExtension(testPlugin)) fun runSync(action: () -> Unit) { if (Bukkit.isPrimaryThread()) { action() } else { Bukkit .getScheduler() .callSyncMethod( testPlugin, Callable { action() null }, ).get() } } suspend fun delayTicks(ticks: Long) { delay(ticks * 50L) } fun scoreAttackMethodLocal(method: java.lang.reflect.Method): Int { var score = 0 val name = method.name val param = method.parameterTypes[0] val declaring = method.declaringClass.simpleName if (name == "attack") score += 100 if (name == "a") score += 80 if (param.simpleName == "Entity") score += 40 if (param.simpleName.contains("Entity")) score += 10 if (method.returnType == Void.TYPE) score += 10 if (method.returnType == java.lang.Boolean.TYPE) score += 8 if (declaring.contains("EntityHuman")) score += 25 if (declaring.contains("EntityPlayer")) score += 20 return score } fun methodSignatureLocal(method: java.lang.reflect.Method): String { val params = method.parameterTypes.joinToString(",") { it.name } return "${method.declaringClass.name}#${method.name}($params):${method.returnType.name}" } fun collectAllMethods(start: Class<*>): List { val methods = LinkedHashMap() var current: Class<*>? = start while (current != null) { current.declaredMethods.forEach { method -> methods.putIfAbsent(methodSignatureLocal(method), method) } current = current.superclass } start.methods.forEach { method -> methods.putIfAbsent(methodSignatureLocal(method), method) } return methods.values.toList() } fun attackNms( attacker: Player, target: LivingEntity, ) { runCatching { attacker.attack(target) return } val attackerHandle = attacker.javaClass.methods .firstOrNull { method -> method.name == "getHandle" && method.parameterCount == 0 }?.invoke(attacker) ?: error("Failed to resolve CraftPlayer#getHandle for attacker") val targetHandle = target.javaClass.methods .firstOrNull { method -> method.name == "getHandle" && method.parameterCount == 0 }?.invoke(target) ?: error("Failed to resolve CraftPlayer#getHandle for target") val attackerHandleClass = attackerHandle.javaClass val targetHandleClass = targetHandle.javaClass runCatching { val managerField = attackerHandleClass.declaredFields.firstOrNull { field -> field.type.simpleName.contains("GameMode") || field.type.simpleName.contains("InteractManager") } if (managerField != null) { managerField.isAccessible = true val manager = managerField.get(attackerHandle) ?: return@runCatching val attackMethod = manager.javaClass.methods.firstOrNull { method -> (method.name == "attack" || method.name == "a") && method.parameterCount == 1 && method.parameterTypes[0].isAssignableFrom(targetHandleClass) } if (attackMethod != null) { attackMethod.isAccessible = true attackMethod.invoke(manager, targetHandle) return } } } val candidates = listOfNotNull( kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector.getMethodAssignable( attackerHandleClass, "attack", targetHandleClass, ), kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector.getMethodAssignable( attackerHandleClass, "a", targetHandleClass, ), ).ifEmpty { collectAllMethods(attackerHandleClass) .asSequence() .filter { it.parameterCount == 1 } .filter { it.parameterTypes[0].isAssignableFrom(targetHandleClass) } .filter { it.returnType == Void.TYPE || it.returnType == java.lang.Boolean.TYPE } .map { method -> method to scoreAttackMethodLocal(method) } .sortedByDescending { it.second } .map { it.first } .toList() } candidates.forEach { it.isAccessible = true } for (method in candidates) { try { val result = method.invoke(attackerHandle, targetHandle) if (result is Boolean && !result) continue return } catch (ignored: Exception) { // try next } } error("Failed to invoke NMS attack for FakePlayer attacker=${attackerHandleClass.name}") } fun resolveDebugFile(): File { val versionTag = Bukkit.getBukkitVersion().replace(Regex("[^A-Za-z0-9_.-]"), "_") val runDir = File(System.getProperty("user.dir")) val repoRoot = runDir.parentFile?.parentFile ?: runDir return File(repoRoot, "build/weapon-durability-debug-$versionTag.txt") } fun appendDebug(line: String) { val file = resolveDebugFile() file.parentFile?.mkdirs() file.appendText(line + "\n") } fun describeNmsState( attacker: Player, victim: LivingEntity, ): String { return runCatching { val attackerHandle = attacker.javaClass.methods .firstOrNull { it.name == "getHandle" && it.parameterCount == 0 } ?.invoke(attacker) ?: return@runCatching "noAttackerHandle" val victimHandle = victim.javaClass.methods .firstOrNull { it.name == "getHandle" && it.parameterCount == 0 } ?.invoke(victim) ?: return@runCatching "noVictimHandle" fun flag( handle: Any, name: String, ): String? { val method = handle.javaClass.methods.firstOrNull { it.name == name && it.parameterCount == 0 } val value = method?.invoke(handle) return value?.toString() } val attackerAlive = flag(attackerHandle, "isAlive") val victimAlive = flag(victimHandle, "isAlive") val victimRemoved = flag(victimHandle, "isRemoved") "attackerAlive=$attackerAlive victimAlive=$victimAlive victimRemoved=$victimRemoved" }.getOrElse { "nmsErr=${it::class.java.simpleName}" } } fun setItemDamage( item: ItemStack, damage: Int, ) { val meta = item.itemMeta if (meta != null) { try { val damageableClass = Class.forName("org.bukkit.inventory.meta.Damageable") if (damageableClass.isInstance(meta)) { val setDamage = damageableClass.getMethod("setDamage", Int::class.javaPrimitiveType) setDamage.invoke(meta, damage) item.itemMeta = meta return } } catch (ignored: ClassNotFoundException) { // Legacy server, fall back to durability. } } @Suppress("DEPRECATION") item.durability = damage.toShort() } fun getItemDamage(item: ItemStack): Int { val meta = item.itemMeta if (meta != null) { try { val damageableClass = Class.forName("org.bukkit.inventory.meta.Damageable") if (damageableClass.isInstance(meta)) { val getDamage = damageableClass.getMethod("getDamage") return (getDamage.invoke(meta) as Number).toInt() } } catch (ignored: ClassNotFoundException) { // Legacy server, fall back to durability. } } @Suppress("DEPRECATION") return item.durability.toInt() } fun setOldModeset(player: Player) { val playerData = getPlayerData(player.uniqueId) playerData.setModesetForWorld(player.world.uid, "old") setPlayerData(player.uniqueId, playerData) } suspend fun withAttackerAndVictim(block: suspend (attacker: Player, victim: LivingEntity) -> Unit) { lateinit var attacker: Player lateinit var victim: LivingEntity val attackerFake = FakePlayer(testPlugin) runSync { val world = checkNotNull(Bukkit.getWorld("world")) attackerFake.spawn(Location(world, 0.0, 100.0, 0.0)) val zombie = world.spawn(Location(world, 1.2, 100.0, 0.0), org.bukkit.entity.Zombie::class.java) attacker = checkNotNull(Bukkit.getPlayer(attackerFake.uuid)) victim = zombie setOldModeset(attacker) attacker.inventory.clear() attacker.activePotionEffects.forEach { attacker.removePotionEffect(it.type) } attacker.isInvulnerable = false victim.isInvulnerable = false victim.health = victim.maxHealth victim.noDamageTicks = 0 } try { repeat(40) { if (attacker.isOnline && attacker.isValid && victim.isValid && !victim.isDead) { if (attacker.world.players.contains(attacker) && attacker.world.entities.any { it.uniqueId == victim.uniqueId }) { return@repeat } } delayTicks(1) } block(attacker, victim) } finally { runSync { attackerFake.removePlayer() if (victim.isValid) victim.remove() } } } test("weapon durability only changes with successful hits during invulnerability") { withAttackerAndVictim { attacker, victim -> appendDebug("invuln:start") try { val weapon = ItemStack(Material.IRON_SWORD) setItemDamage(weapon, 0) runSync { attacker.inventory.setItemInMainHand(weapon) victim.maximumNoDamageTicks = 100 victim.noDamageTicks = 0 attacker.gameMode = org.bukkit.GameMode.SURVIVAL val direction = victim.location.toVector().subtract(attacker.location.toVector()) attacker.teleport(attacker.location.setDirection(direction)) } delayTicks(5) appendDebug( "invuln:state attackerValid=${attacker.isValid} victimValid=${victim.isValid} " + "victimDead=${victim.isDead} " + "victimInWorld=${victim.world.entities.any { it.uniqueId == victim.uniqueId }} " + "worldPvp=${victim.world.pvp} " + "nms=${describeNmsState(attacker, victim)}", ) val hitCount = AtomicInteger(0) val totalHitCount = AtomicInteger(0) val cancelledHitCount = AtomicInteger(0) val victimEventCount = AtomicInteger(0) val anyDamageEventCount = AtomicInteger(0) val allDamageEventCount = AtomicInteger(0) val itemDamageCount = AtomicInteger(0) val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onHit(event: EntityDamageByEntityEvent) { if (event.entity.uniqueId == victim.uniqueId) { victimEventCount.incrementAndGet() if (event.damager == attacker) { totalHitCount.incrementAndGet() if (event.isCancelled) { cancelledHitCount.incrementAndGet() } else { hitCount.incrementAndGet() } } } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onAnyDamage(event: EntityDamageEvent) { allDamageEventCount.incrementAndGet() if (event.entity.uniqueId == victim.uniqueId) { anyDamageEventCount.incrementAndGet() } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onItemDamage(event: PlayerItemDamageEvent) { if (event.player == attacker && event.item.type == Material.IRON_SWORD) { itemDamageCount.addAndGet(event.damage) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { runSync { Bukkit.getPluginManager().callEvent( EntityDamageEvent(victim, EntityDamageEvent.DamageCause.CUSTOM, 0.1), ) } delayTicks(1) appendDebug("invuln:afterManualEvent allDamageEvents=${allDamageEventCount.get()}") runSync { attackNms(attacker, victim) } delayTicks(1) repeat(10) { runSync { attackNms(attacker, victim) } delayTicks(1) } delayTicks(2) } finally { runSync { HandlerList.unregisterAll(listener) } } val hits = hitCount.get() val totalHits = totalHitCount.get() val cancelledHits = cancelledHitCount.get() val damageEvents = itemDamageCount.get() val actualDamage = getItemDamage(attacker.inventory.itemInMainHand) if (totalHits == 0) { val beforeHealth = victim.health runSync { victim.damage(1.0, attacker) } delayTicks(1) appendDebug( "invuln:afterDamage totalHits=${totalHitCount.get()} " + "cancelledHits=${cancelledHitCount.get()} healthBefore=$beforeHealth healthAfter=${victim.health}", ) } appendDebug( "invuln:hits=$hits totalHits=$totalHits cancelledHits=$cancelledHits " + "victimEvents=${victimEventCount.get()} anyDamageEvents=${anyDamageEventCount.get()} " + "allDamageEvents=${allDamageEventCount.get()} " + "itemDamageEvents=$damageEvents itemDamage=$actualDamage", ) if (hits <= 0) { // Retry a few swings in case legacy fake player validity lagged. repeat(5) { runSync { victim.noDamageTicks = 0 attackNms(attacker, victim) } delayTicks(1) } } val finalHits = hitCount.get() val finalDamageEvents = itemDamageCount.get() val finalItemDamage = getItemDamage(attacker.inventory.itemInMainHand) val isModern = kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector .versionIsNewerOrEqualTo(1, 12, 0) if (!isModern) { // Legacy 1.9 durability behaviour is inconsistent; ensure we at least don't crash. return@withAttackerAndVictim } if (finalHits <= 0) { error("Expected at least one successful hit, got $finalHits") } if (finalDamageEvents != finalHits || finalItemDamage != finalHits) { error( "Durability changed per click, not per hit: hits=$finalHits " + "itemDamageEvents=$finalDamageEvents itemDamage=$finalItemDamage", ) } } catch (e: Throwable) { appendDebug("invuln:error=${e::class.java.simpleName}: ${e.message}") throw e } } } test("weapon durability increments on hits after invulnerability expires") { withAttackerAndVictim { attacker, victim -> appendDebug("expire:start") try { val weapon = ItemStack(Material.IRON_SWORD) setItemDamage(weapon, 0) runSync { attacker.inventory.setItemInMainHand(weapon) victim.maximumNoDamageTicks = 10 victim.noDamageTicks = 0 attacker.gameMode = org.bukkit.GameMode.SURVIVAL val direction = victim.location.toVector().subtract(attacker.location.toVector()) attacker.teleport(attacker.location.setDirection(direction)) } delayTicks(5) appendDebug( "expire:state attackerValid=${attacker.isValid} victimValid=${victim.isValid} " + "victimDead=${victim.isDead} " + "victimInWorld=${victim.world.entities.any { it.uniqueId == victim.uniqueId }} " + "worldPvp=${victim.world.pvp} " + "nms=${describeNmsState(attacker, victim)}", ) val hitCount = AtomicInteger(0) val totalHitCount = AtomicInteger(0) val cancelledHitCount = AtomicInteger(0) val victimEventCount = AtomicInteger(0) val anyDamageEventCount = AtomicInteger(0) val allDamageEventCount = AtomicInteger(0) val itemDamageCount = AtomicInteger(0) val listener = object : Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onHit(event: EntityDamageByEntityEvent) { if (event.entity.uniqueId == victim.uniqueId) { victimEventCount.incrementAndGet() if (event.damager == attacker) { totalHitCount.incrementAndGet() if (event.isCancelled) { cancelledHitCount.incrementAndGet() } else { hitCount.incrementAndGet() } } } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = false) fun onAnyDamage(event: EntityDamageEvent) { allDamageEventCount.incrementAndGet() if (event.entity.uniqueId == victim.uniqueId) { anyDamageEventCount.incrementAndGet() } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) fun onItemDamage(event: PlayerItemDamageEvent) { if (event.player == attacker && event.item.type == Material.IRON_SWORD) { itemDamageCount.addAndGet(event.damage) } } } runSync { Bukkit.getPluginManager().registerEvents(listener, testPlugin) } try { runSync { Bukkit.getPluginManager().callEvent( EntityDamageEvent(victim, EntityDamageEvent.DamageCause.CUSTOM, 0.1), ) } delayTicks(1) appendDebug("expire:afterManualEvent allDamageEvents=${allDamageEventCount.get()}") runSync { attackNms(attacker, victim) } delayTicks(12) runSync { attackNms(attacker, victim) } delayTicks(2) } finally { runSync { HandlerList.unregisterAll(listener) } } val hits = hitCount.get() val totalHits = totalHitCount.get() val cancelledHits = cancelledHitCount.get() val damageEvents = itemDamageCount.get() val actualDamage = getItemDamage(attacker.inventory.itemInMainHand) if (totalHits == 0) { val beforeHealth = victim.health runSync { victim.damage(1.0, attacker) } delayTicks(1) appendDebug( "expire:afterDamage totalHits=${totalHitCount.get()} " + "cancelledHits=${cancelledHitCount.get()} healthBefore=$beforeHealth healthAfter=${victim.health}", ) } appendDebug( "expire:hits=$hits totalHits=$totalHits cancelledHits=$cancelledHits " + "victimEvents=${victimEventCount.get()} anyDamageEvents=${anyDamageEventCount.get()} " + "allDamageEvents=${allDamageEventCount.get()} " + "itemDamageEvents=$damageEvents itemDamage=$actualDamage", ) if (hits < 2) { repeat(4) { runSync { attackNms(attacker, victim) } delayTicks(2) } } val finalHits = hitCount.get() val finalDamageEvents = itemDamageCount.get() val finalItemDamage = getItemDamage(attacker.inventory.itemInMainHand) val isModern = kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector .versionIsNewerOrEqualTo(1, 12, 0) if (!isModern) { // Legacy 1.9 durability behaviour is inconsistent; ensure we at least don't crash. return@withAttackerAndVictim } val expectedHits = 2 if (finalHits < expectedHits) { error("Expected at least $expectedHits hits after invulnerability expiry, got $finalHits") } if (finalDamageEvents != finalHits || finalItemDamage != finalHits) { error( "Durability did not match hits: hits=$finalHits " + "itemDamageEvents=$finalDamageEvents itemDamage=$finalItemDamage", ) } } catch (e: Throwable) { appendDebug("expire:error=${e::class.java.simpleName}: ${e.message}") throw e } } } }) ================================================ FILE: src/integrationTest/resources/plugin.yml ================================================ # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at https://mozilla.org/MPL/2.0/. main: kernitus.plugin.OldCombatMechanics.OCMTestMain name: OldCombatMechanicsTest version: 0.0.1 authors: [ kernitus, Rayzr522 ] description: Reverts to pre-1.9 combat mechanics website: https://github.com/kernitus/BukkitOldCombatMechanics load: POSTWORLD softdepend: [ OldCombatMechanics ] api-version: 1.13 ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/ModuleLoader.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import kernitus.plugin.OldCombatMechanics.utilities.EventRegistry; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import java.util.ArrayList; import java.util.List; public class ModuleLoader { private static EventRegistry eventRegistry; private static final List modules = new ArrayList<>(); public static void initialise(OCMMain plugin) { modules.clear(); ModuleLoader.eventRegistry = new EventRegistry(plugin); } public static void toggleModules() { modules.forEach(module -> setState(module, module.isEnabled())); } private static void setState(OCMModule module, boolean state) { if (state) { if (eventRegistry.registerListener(module)) { Messenger.debug("Enabled " + module.getClass().getSimpleName()); } } else { if (eventRegistry.unregisterListener(module)) { Messenger.debug("Disabled " + module.getClass().getSimpleName()); } } } public static void addModule(OCMModule module) { modules.add(module); } public static List getModules() { return modules; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/OCMConfigHandler.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.YamlConfiguration; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; public class OCMConfigHandler { private final String CONFIG_NAME = "config.yml"; private final OCMMain plugin; public OCMConfigHandler(OCMMain instance) { this.plugin = instance; } public void upgradeConfig() { // Remove old backup file if present final File backup = getFile("config-backup.yml"); if (backup.exists()) backup.delete(); // Keeping YAML comments not available in lower versions if (Reflector.versionIsNewerOrEqualTo(1, 18, 1) || Config.getConfig().getBoolean("force-below-1-18-1-config-upgrade", false) ) { plugin.getLogger().warning("Config version does not match, upgrading old config"); final File configFile = getFile(CONFIG_NAME); // Back up the old config file if (!configFile.renameTo(backup)) { plugin.getLogger().severe("Could not back up old config file. Aborting config upgrade."); return; } // Save the new default config from the JAR to config.yml. This ensures all old keys are gone. plugin.saveResource(CONFIG_NAME, true); // Now, load the old values from the backup and the new config from the fresh file final YamlConfiguration oldConfig = YamlConfiguration.loadConfiguration(backup); final YamlConfiguration newConfig = YamlConfiguration.loadConfiguration(configFile); // Copy user's values for keys that still exist for (String key : newConfig.getKeys(true)) { if (key.equals("config-version")) continue; if (newConfig.isConfigurationSection(key)) continue; if (oldConfig.contains(key) && !oldConfig.isConfigurationSection(key)) { newConfig.set(key, oldConfig.get(key)); } } migrateModuleLists(oldConfig, newConfig); // Save the final, merged config try { newConfig.save(configFile); plugin.getLogger().info("Config has been updated. A backup of your old config is available at config-backup.yml"); } catch (IOException e) { plugin.getLogger().severe("Failed to save upgraded config. It has been restored from backup."); e.printStackTrace(); backup.renameTo(configFile); // Restore backup } } else { plugin.getLogger().warning("Config version does not match, backing up old config and creating a new one"); // Change name of old config final File configFile = getFile(CONFIG_NAME); configFile.renameTo(backup); } // Save new version if none is present setupConfigIfNotPresent(); } /** * Generates new config.yml file, if not present. */ public void setupConfigIfNotPresent() { if (!doesConfigExist()) { plugin.saveDefaultConfig(); plugin.getLogger().info("Config file generated"); } } private void migrateModuleLists(YamlConfiguration oldConfig, YamlConfiguration newConfig) { final Set internalModules = new HashSet<>(Arrays.asList( "modeset-listener", "attack-cooldown-tracker", "entity-damage-listener" )); final Set optionalModules = new HashSet<>(Arrays.asList( "disable-attack-sounds", "disable-sword-sweep-particles" )); final Set moduleNames = ModuleLoader.getModules().stream() .map(module -> module.getConfigName().toLowerCase(Locale.ROOT)) .collect(Collectors.toCollection(LinkedHashSet::new)); final ConfigurationSection oldModesets = oldConfig.getConfigurationSection("modesets"); final Map> migratedModesets = new LinkedHashMap<>(); final Set modulesInModesets = new HashSet<>(); if (oldModesets != null) { for (String modesetName : oldModesets.getKeys(false)) { final List moduleList = oldModesets.getStringList(modesetName); final List normalisedList = moduleList.stream() .map(name -> name.toLowerCase(Locale.ROOT)) .collect(Collectors.toList()); normalisedList.removeIf(internalModules::contains); migratedModesets.put(modesetName, normalisedList); modulesInModesets.addAll(normalisedList); } } moduleNames.addAll(optionalModules); if (moduleNames.isEmpty()) { for (String key : oldConfig.getKeys(true)) { if (!key.endsWith(".enabled")) { continue; } final String moduleName = key.substring(0, key.length() - ".enabled".length()) .toLowerCase(Locale.ROOT); if (internalModules.contains(moduleName)) { continue; } moduleNames.add(moduleName); } moduleNames.addAll(modulesInModesets); } moduleNames.removeAll(internalModules); final List alwaysEnabled = new ArrayList<>(); final List disabledModules = new ArrayList<>(); for (String moduleName : moduleNames) { final String enabledKey = moduleName + ".enabled"; if ("attack-range".equals(moduleName)) { disabledModules.add(moduleName); continue; } final boolean enabled = !oldConfig.contains(enabledKey) || oldConfig.getBoolean(enabledKey); if (!enabled) { disabledModules.add(moduleName); continue; } if (!modulesInModesets.contains(moduleName)) { alwaysEnabled.add(moduleName); } } // Remove disabled modules from all modesets if (!disabledModules.isEmpty()) { for (Map.Entry> entry : migratedModesets.entrySet()) { entry.getValue().removeIf(disabledModules::contains); } } newConfig.set("always_enabled_modules", alwaysEnabled); newConfig.set("disabled_modules", disabledModules); if (!migratedModesets.isEmpty()) { ConfigurationSection targetModesets = newConfig.getConfigurationSection("modesets"); if (targetModesets == null) { targetModesets = newConfig.createSection("modesets"); } // Remove old keys that are no longer present, without deleting the section (keeps placement) for (String key : new ArrayList<>(targetModesets.getKeys(false))) { if (!migratedModesets.containsKey(key)) { targetModesets.set(key, null); } } // Apply migrated entries for (Map.Entry> entry : migratedModesets.entrySet()) { targetModesets.set(entry.getKey(), entry.getValue()); } } final ConfigurationSection oldWorlds = oldConfig.getConfigurationSection("worlds"); if (oldWorlds != null) { for (String worldName : oldWorlds.getKeys(false)) { newConfig.set("worlds." + worldName, oldWorlds.getStringList(worldName)); } } } public YamlConfiguration getConfig(String fileName) { return YamlConfiguration.loadConfiguration(getFile(fileName)); } public File getFile(String fileName) { return new File(plugin.getDataFolder(), fileName.replace('/', File.separatorChar)); } public boolean doesConfigExist() { return getFile(CONFIG_NAME).exists(); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/OCMMain.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics; import com.github.retrooper.packetevents.PacketEvents; import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder; import kernitus.plugin.OldCombatMechanics.commands.OCMCommandCompleter; import kernitus.plugin.OldCombatMechanics.commands.OCMCommandHandler; import kernitus.plugin.OldCombatMechanics.hooks.PlaceholderAPIHook; import kernitus.plugin.OldCombatMechanics.hooks.api.Hook; import kernitus.plugin.OldCombatMechanics.module.*; import kernitus.plugin.OldCombatMechanics.updater.ModuleUpdateChecker; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.damage.AttackCooldownTracker; import kernitus.plugin.OldCombatMechanics.utilities.damage.EntityDamageByEntityListener; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import kernitus.plugin.OldCombatMechanics.utilities.storage.ModesetListener; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage; import org.bstats.bukkit.Metrics; import org.bstats.charts.SimpleBarChart; import org.bstats.charts.SimplePie; import org.bukkit.Bukkit; import org.bukkit.entity.HumanEntity; import org.bukkit.event.EventException; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.plugin.PluginDescriptionFile; import org.bukkit.plugin.RegisteredListener; import org.bukkit.plugin.java.JavaPlugin; import org.jetbrains.annotations.NotNull; import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.logging.Logger; import java.util.stream.Collectors; public class OCMMain extends JavaPlugin { private static OCMMain INSTANCE; private final Logger logger = getLogger(); private final OCMConfigHandler CH = new OCMConfigHandler(this); private final List disableListeners = new ArrayList<>(); private final List enableListeners = new ArrayList<>(); private final List hooks = new ArrayList<>(); public OCMMain() { super(); } @Override public void onLoad() { PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this)); PacketEvents.getAPI().load(); } @Override public void onEnable() { INSTANCE = this; // Setting up config.yml CH.setupConfigIfNotPresent(); // Initialise persistent player storage PlayerStorage.initialise(this); // Initialise ModuleLoader utility ModuleLoader.initialise(this); // Initialise Config utility Config.initialise(this); // Initialise the Messenger utility Messenger.initialise(this); PacketEvents.getAPI().init(); // Register all the modules registerModules(); // Register all hooks for integrating with other plugins registerHooks(); // Initialise all the hooks hooks.forEach(hook -> hook.init(this)); // Set up the command handler getCommand("OldCombatMechanics").setExecutor(new OCMCommandHandler(this)); // Set up command tab completer getCommand("OldCombatMechanics").setTabCompleter(new OCMCommandCompleter()); Config.reload(); // BStats Metrics final Metrics metrics = new Metrics(this, 53); metrics.addCustomChart(new SimplePie("server_software", () -> { final String name = Bukkit.getServer().getName(); if (name == null || name.isEmpty()) return "Unknown"; final String cleaned = name.split("\\s", 2)[0].trim(); return cleaned.isEmpty() ? "Unknown" : cleaned; })); // Simple bar chart (kept in case bStats re-enables bar display) metrics.addCustomChart( new SimpleBarChart( "enabled_modules", () -> ModuleLoader.getModules().stream() .filter(OCMModule::isEnabled) .collect(Collectors.toMap(OCMModule::toString, module -> 1)))); // Pie chart of enabled/disabled for each module ModuleLoader.getModules().forEach(module -> metrics.addCustomChart( new SimplePie(module.getModuleName() + "_pie", () -> module.isEnabled() ? "enabled" : "disabled"))); // Simple pie: exact count of enabled modules per server (as a string key). metrics.addCustomChart(new SimplePie("enabled_modules_count", () -> { int count = (int) ModuleLoader.getModules().stream().filter(OCMModule::isEnabled).count(); return Integer.toString(count); })); enableListeners.forEach(Runnable::run); // Properly handle Plugman load/unload. final List joinListeners = Arrays .stream(PlayerJoinEvent.getHandlerList().getRegisteredListeners()) .filter(registeredListener -> registeredListener.getPlugin().equals(this)) .collect(Collectors.toList()); Bukkit.getOnlinePlayers().forEach(player -> { final PlayerJoinEvent event = new PlayerJoinEvent(player, ""); // Trick all the modules into thinking the player just joined in case the plugin // was loaded with Plugman. // This way attack speeds, item modifications, etc. will be applied immediately // instead of after a re-log. joinListeners.forEach(registeredListener -> { try { registeredListener.callEvent(event); } catch (EventException e) { e.printStackTrace(); } }); }); // Logging to console the enabling of OCM final PluginDescriptionFile pdfFile = this.getDescription(); logger.info(pdfFile.getName() + " v" + pdfFile.getVersion() + " has been enabled"); if (Config.moduleEnabled("update-checker")) Bukkit.getScheduler().runTaskLaterAsynchronously(this, () -> new UpdateChecker(this).performUpdate(), 20L); metrics.addCustomChart(new SimplePie("auto_update_pie", () -> Config.moduleSettingEnabled("update-checker", "auto-update") ? "enabled" : "disabled")); } @Override public void onDisable() { final PluginDescriptionFile pdfFile = this.getDescription(); disableListeners.forEach(Runnable::run); // Properly handle Plugman load/unload. final List quitListeners = Arrays .stream(PlayerQuitEvent.getHandlerList().getRegisteredListeners()) .filter(registeredListener -> registeredListener.getPlugin().equals(this)) .collect(Collectors.toList()); // Trick all the modules into thinking the player just quit in case the plugin // was unloaded with Plugman. // This way attack speeds, item modifications, etc. will be restored immediately // instead of after a disconnect. Bukkit.getOnlinePlayers().forEach(player -> { final PlayerQuitEvent event = new PlayerQuitEvent(player, ""); quitListeners.forEach(registeredListener -> { try { registeredListener.callEvent(event); } catch (EventException e) { e.printStackTrace(); } }); }); PlayerStorage.instantSave(); PacketEvents.getAPI().terminate(); // Logging to console the disabling of OCM logger.info(pdfFile.getName() + " v" + pdfFile.getVersion() + " has been disabled"); } private void registerModules() { // Update Checker (also a module, so we can use the dynamic // registering/unregistering) ModuleLoader.addModule(new ModuleUpdateChecker(this)); // Modeset listener, for when player joins or changes world ModuleLoader.addModule(new ModesetListener(this)); // Module listeners ModuleLoader.addModule(new ModuleAttackCooldown(this)); ModuleLoader.addModule(new ModuleAttackRange(this)); // If below 1.16, we need to keep track of player attack cooldown ourselves if (Reflector.getMethod(HumanEntity.class, "getAttackCooldown", 0) == null) { ModuleLoader.addModule(new AttackCooldownTracker(this)); } // Listeners registered later with same priority are called later // These four listen to OCMEntityDamageByEntityEvent: ModuleLoader.addModule(new ModuleOldToolDamage(this)); ModuleLoader.addModule(new ModuleSwordSweep(this)); ModuleLoader.addModule(new ModuleOldPotionEffects(this)); ModuleLoader.addModule(new ModuleOldCriticalHits(this)); // Next block are all on LOWEST priority, so will be called in the following // order: // Damage order: base -> potion effects -> critical hit -> enchantments // Defence order: overdamage -> blocking -> armour -> resistance -> armour enchs // -> absorption // EntityDamageByEntityListener calls OCMEntityDamageByEntityEvent, see modules // above // For everything from base to overdamage ModuleLoader.addModule(new EntityDamageByEntityListener(this)); // ModuleSwordBlocking to calculate blocking ModuleLoader.addModule(new ModuleShieldDamageReduction(this)); // OldArmourStrength for armour -> resistance -> armour enchs -> absorption ModuleLoader.addModule(new ModuleOldArmourStrength(this)); ModuleLoader.addModule(new ModuleSwordBlocking(this)); ModuleLoader.addModule(new ModuleOldArmourDurability(this)); ModuleLoader.addModule(new ModuleGoldenApple(this)); ModuleLoader.addModule(new ModuleFishingKnockback(this)); ModuleLoader.addModule(new ModulePlayerKnockback(this)); ModuleLoader.addModule(new ModulePlayerRegen(this)); ModuleLoader.addModule(new ModuleDisableCrafting(this)); ModuleLoader.addModule(new ModuleDisableOffHand(this)); ModuleLoader.addModule(new ModuleOldBrewingStand(this)); ModuleLoader.addModule(new ModuleProjectileKnockback(this)); ModuleLoader.addModule(new ModuleDisableEnderpearlCooldown(this)); ModuleLoader.addModule(new ModuleChorusFruit(this)); ModuleLoader.addModule(new ModuleOldBurnDelay(this)); ModuleLoader.addModule(new ModuleAttackFrequency(this)); ModuleLoader.addModule(new ModuleFishingRodVelocity(this)); ModuleLoader.addModule(new ModuleAttackSounds(this)); ModuleLoader.addModule(new ModuleSwordSweepParticles(this)); } private void registerHooks() { if (getServer().getPluginManager().isPluginEnabled("PlaceholderAPI")) hooks.add(new PlaceholderAPIHook()); } public void upgradeConfig() { CH.upgradeConfig(); } public boolean doesConfigExist() { return CH.doesConfigExist(); } /** * Registers a runnable to run when the plugin gets disabled. * * @param action the {@link Runnable} to run when the plugin gets disabled */ public void addDisableListener(Runnable action) { disableListeners.add(action); } /** * Registers a runnable to run when the plugin gets enabled. * * @param action the {@link Runnable} to run when the plugin gets enabled */ public void addEnableListener(Runnable action) { enableListeners.add(action); } /** * Get the plugin's JAR file * * @return The File object corresponding to this plugin */ @NotNull @Override public File getFile() { return super.getFile(); } public static OCMMain getInstance() { return INSTANCE; } public static String getVersion() { return INSTANCE.getDescription().getVersion(); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/UpdateChecker.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics; import kernitus.plugin.OldCombatMechanics.updater.SpigetUpdateChecker; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.ChatColor; import org.bukkit.entity.Player; import javax.annotation.Nullable; import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; public class UpdateChecker { private final SpigetUpdateChecker updater; private final boolean autoDownload; private final OCMMain plugin; public UpdateChecker(OCMMain plugin) { updater = new SpigetUpdateChecker(); this.plugin = plugin; // We don't really want to auto update if the config is not going to be upgraded automatically autoDownload = Config.moduleSettingEnabled("update-checker", "auto-update") && (Reflector.versionIsNewerOrEqualTo(1, 18, 1) || Config.getConfig().getBoolean("force-below-1-18-1-config-upgrade", false) ); } public void performUpdate() { performUpdate(null); } public void performUpdate(@Nullable Player player) { if (player != null) update(player::sendMessage); else update(Messenger::info); } private void update(Consumer target) { final List messages = new ArrayList<>(); if (updater.isUpdateAvailable()) { messages.add(ChatColor.BLUE + "An update for OldCombatMechanics to version " + updater.getLatestVersion() + " is available!"); if (!autoDownload) { messages.add(ChatColor.BLUE + "Click here to download it: " + ChatColor.GRAY + updater.getUpdateURL()); } else { messages.add(ChatColor.BLUE + "Downloading update: " + ChatColor.GRAY + updater.getUpdateURL()); try { if (updater.downloadLatestVersion(plugin.getServer().getUpdateFolderFile(), plugin.getFile().getName())) messages.add(ChatColor.GREEN + "Update downloaded. Restart or reload server to enable new version."); else throw new RuntimeException(); } catch (Exception e) { messages.add(ChatColor.RED + "Error occurred while downloading update! Check console for more details"); e.printStackTrace(); } } } messages.forEach(target); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/commands/OCMCommandCompleter.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.commands; import kernitus.plugin.OldCombatMechanics.utilities.Config; import org.bukkit.Bukkit; import org.bukkit.World; import org.bukkit.command.Command; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import static kernitus.plugin.OldCombatMechanics.commands.OCMCommandHandler.Subcommand; /** * Provides tab completion for OCM commands */ public class OCMCommandCompleter implements TabCompleter { @Nullable @Override public List onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) { final List completions = new ArrayList<>(); if (args.length < 2) { completions.addAll(Arrays.stream(Subcommand.values()) .filter(arg -> arg.toString().startsWith(args[0])) .filter(arg -> OCMCommandHandler.checkPermissions(sender, arg)) .map(Enum::toString).collect(Collectors.toList())); } else if (args[0].equalsIgnoreCase(Subcommand.mode.toString())) { if (args.length < 3) { if (sender.hasPermission("oldcombatmechanics.mode.others") || sender.hasPermission("oldcombatmechanics.mode.own") ) { if (sender instanceof Player) { // Get the modesets allowed in the world player is in final World world = ((Player) sender).getWorld(); completions.addAll( Config.getWorlds() // If world not in config, all modesets allowed .getOrDefault(world.getUID(), Config.getModesets().keySet()) .stream() .filter(ms -> ms.startsWith(args[1])) .collect(Collectors.toList())); } else { completions.addAll(Config.getModesets().keySet().stream() .filter(ms -> ms.startsWith(args[1])) .collect(Collectors.toList())); } } } else if (sender.hasPermission("oldcombatmechanics.mode.others")) { completions.addAll(Bukkit.getOnlinePlayers().stream() .map(Player::getName) .filter(arg -> arg.startsWith(args[2])) .collect(Collectors.toList())); } } return completions; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/commands/OCMCommandHandler.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.commands; import kernitus.plugin.OldCombatMechanics.ModuleLoader; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerData; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.bukkit.plugin.PluginDescriptionFile; import org.jetbrains.annotations.NotNull; import java.util.Locale; import java.util.Set; import java.util.UUID; public class OCMCommandHandler implements CommandExecutor { private static final String NO_PERMISSION = "&cYou need the permission '%s' to do that!"; private final OCMMain plugin; enum Subcommand { reload, mode } public OCMCommandHandler(OCMMain instance) { this.plugin = instance; } private void help(OCMMain plugin, CommandSender sender) { final PluginDescriptionFile description = plugin.getDescription(); Messenger.sendNoPrefix(sender, ChatColor.DARK_GRAY + Messenger.HORIZONTAL_BAR); Messenger.sendNoPrefix(sender, "&6&lOldCombatMechanics&e by &ckernitus&e and &cRayzr522&e version &6%s", description.getVersion()); if (checkPermissions(sender, Subcommand.reload)) Messenger.sendNoPrefix(sender, "&eYou can use &c/ocm reload&e to reload the config file"); if (checkPermissions(sender, Subcommand.mode)) Messenger.sendNoPrefix(sender, Config.getConfig().getString("mode-messages.message-usage", "&4ERROR: &rmode-messages.message-usage string missing")); Messenger.sendNoPrefix(sender, ChatColor.DARK_GRAY + Messenger.HORIZONTAL_BAR); } private void reload(CommandSender sender) { Config.reload(); Messenger.sendNoPrefix(sender, "&6&lOldCombatMechanics&e config file reloaded"); } private void mode(CommandSender sender, String[] args) { // If just /ocm mode if (args.length < 2) { if (sender instanceof Player) { final Player player = ((Player) sender); final PlayerData playerData = PlayerStorage.getPlayerData(player.getUniqueId()); String modeName = playerData.getModesetForWorld(player.getWorld().getUID()); if (modeName == null || modeName.isEmpty()) modeName = "unknown"; Messenger.send(sender, Config.getConfig().getString("mode-messages.mode-status", "&4ERROR: &rmode-messages.mode-status string missing"), modeName); } Messenger.send(sender, Config.getConfig().getString("mode-messages.message-usage", "&4ERROR: &rmode-messages.message-usage string missing")); return; } final String modesetName = args[1].toLowerCase(Locale.ROOT); if (!Config.getModesets().containsKey(modesetName)) { Messenger.send(sender, Config.getConfig().getString("mode-messages.invalid-modeset", "&4ERROR: &rmode-messages.invalid-modeset string missing")); return; } Player player = null; // If /ocm mode if (args.length < 3) { if (sender instanceof Player) { if (!sender.hasPermission("oldcombatmechanics.mode.own")) { Messenger.sendNoPrefix(sender, NO_PERMISSION, "oldcombatmechanics.mode.own"); return; } player = (Player) sender; } else { Messenger.send(sender, Config.getConfig().getString("mode-messages.invalid-player", "&4ERROR: &rmode-messages.invalid-player string missing")); return; } } else { // If /ocm mode if (!sender.hasPermission("oldcombatmechanics.mode.others")) { Messenger.sendNoPrefix(sender, NO_PERMISSION, "oldcombatmechanics.mode.others"); return; } player = Bukkit.getPlayer(args[2]); } if (player == null) { Messenger.send(sender, Config.getConfig().getString("mode-messages.invalid-player", "&4ERROR: &rmode-messages.invalid-player string missing")); return; } final UUID worldId = player.getWorld().getUID(); final Set worldModesets = Config.getWorlds().get(worldId); // If modesets null or empty it means not configured, so all are allowed if (worldModesets != null && !worldModesets.isEmpty() && !worldModesets.contains(modesetName)) { // Modeset not allowed in current world Messenger.send(sender, Config.getConfig().getString("mode-messages.invalid-modeset", "&4ERROR: &rmode-messages.invalid-modeset string missing")); return; } final PlayerData playerData = PlayerStorage.getPlayerData(player.getUniqueId()); playerData.setModesetForWorld(worldId, modesetName); PlayerStorage.setPlayerData(player.getUniqueId(), playerData); PlayerStorage.scheduleSave(); Messenger.send(sender, Config.getConfig().getString("mode-messages.mode-set", "&4ERROR: &rmode-messages.mode-set string missing"), modesetName); // Re-apply things like attack speed and collision team final Player playerCopy = player; ModuleLoader.getModules().forEach(module -> module.onModesetChange(playerCopy)); } public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String label, String[] args) { if (args.length < 1) { help(plugin, sender); } else { try { try { final Subcommand subcommand = Subcommand.valueOf(args[0].toLowerCase(Locale.ROOT)); if (checkPermissions(sender, subcommand, true)) { switch (subcommand) { case reload: reload(sender); break; case mode: mode(sender, args); break; default: throw new CommandNotRecognisedException(); } } } catch (IllegalArgumentException e) { throw new CommandNotRecognisedException(); } } catch (CommandNotRecognisedException e) { Messenger.send(sender, "Subcommand not recognised!"); } } return true; } private static class CommandNotRecognisedException extends IllegalArgumentException { } static boolean checkPermissions(CommandSender sender, Subcommand subcommand) { return checkPermissions(sender, subcommand, false); } static boolean checkPermissions(CommandSender sender, Subcommand subcommand, boolean sendMessage) { final boolean hasPermission = sender.hasPermission("oldcombatmechanics." + subcommand); if (sendMessage && !hasPermission) Messenger.sendNoPrefix(sender, NO_PERMISSION, "oldcombatmechanics." + subcommand); return hasPermission; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/hooks/PlaceholderAPIHook.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.hooks; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.hooks.api.Hook; import kernitus.plugin.OldCombatMechanics.module.ModuleDisableEnderpearlCooldown; import kernitus.plugin.OldCombatMechanics.module.ModuleGoldenApple; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerData; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage; import me.clip.placeholderapi.expansion.PlaceholderExpansion; import org.bukkit.entity.Player; import org.jetbrains.annotations.NotNull; public class PlaceholderAPIHook implements Hook { private PlaceholderExpansion expansion; @Override public void init(OCMMain plugin) { expansion = new PlaceholderExpansion() { @Override public boolean canRegister() { return true; } @Override public boolean persist() { return true; } @Override public @NotNull String getIdentifier() { return "ocm"; } @Override public @NotNull String getAuthor() { return String.join(", ", plugin.getDescription().getAuthors()); } @Override public @NotNull String getVersion() { return plugin.getDescription().getVersion(); } @Override public String onPlaceholderRequest(Player player, @NotNull String identifier) { if (player == null) return null; switch (identifier) { case "modeset": return getModeset(player); case "gapple_cooldown": return getGappleCooldown(player); case "napple_cooldown": return getNappleCooldown(player); case "enderpearl_cooldown": return getEnderpearlCooldown(player); } return null; } private String getGappleCooldown(Player player) { final long seconds = ModuleGoldenApple.getInstance().getGappleCooldown(player.getUniqueId()); return seconds > 0 ? String.valueOf(seconds) : "None"; } private String getNappleCooldown(Player player) { final long seconds = ModuleGoldenApple.getInstance().getNappleCooldown(player.getUniqueId()); return seconds > 0 ? String.valueOf(seconds) : "None"; } private String getEnderpearlCooldown(Player player) { final long seconds = ModuleDisableEnderpearlCooldown.getInstance().getEnderpearlCooldown(player.getUniqueId()); return seconds > 0 ? String.valueOf(seconds) : "None"; } private String getModeset(Player player) { final PlayerData playerData = PlayerStorage.getPlayerData(player.getUniqueId()); String modeName = playerData.getModesetForWorld(player.getWorld().getUID()); if (modeName == null || modeName.isEmpty()) modeName = "unknown"; return modeName; } }; expansion.register(); } @Override public void deinit(OCMMain plugin) { if (expansion != null) { expansion.unregister(); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/hooks/api/Hook.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.hooks.api; import kernitus.plugin.OldCombatMechanics.OCMMain; public interface Hook { void init(OCMMain plugin); void deinit(OCMMain plugin); } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleAttackCooldown.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.cryptomorin.xseries.XAttribute; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.ConfigUtils; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.attribute.AttributeInstance; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.event.player.PlayerItemHeldEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerSwapHandItemsEvent; import org.bukkit.inventory.ItemStack; import java.util.Collections; import java.util.Map; /** * Disables the attack cooldown. */ public class ModuleAttackCooldown extends OCMModule { private static final double VANILLA_ATTACK_SPEED = 4.0; private double genericAttackSpeed = 40.0; private Map heldItemAttackSpeeds = Collections.emptyMap(); public ModuleAttackCooldown(OCMMain plugin) { super(plugin, "disable-attack-cooldown"); } @Override public void reload() { genericAttackSpeed = module().getDouble("generic-attack-speed", 40.0); heldItemAttackSpeeds = Collections.emptyMap(); if (module().isConfigurationSection("held-item-attack-speeds")) { heldItemAttackSpeeds = ConfigUtils.loadMaterialDoubleMap(module().getConfigurationSection("held-item-attack-speeds")); } Bukkit.getOnlinePlayers().forEach(this::adjustAttackSpeed); } @EventHandler(priority = EventPriority.HIGH) public void onPlayerLogin(PlayerJoinEvent e) { adjustAttackSpeed(e.getPlayer()); } @EventHandler(priority = EventPriority.HIGH) public void onWorldChange(PlayerChangedWorldEvent e) { adjustAttackSpeed(e.getPlayer()); } @EventHandler(priority = EventPriority.HIGHEST) public void onHotbarChange(PlayerItemHeldEvent e) { if (e.isCancelled()) { adjustAttackSpeed(e.getPlayer()); } else { adjustAttackSpeed(e.getPlayer(), e.getPlayer().getInventory().getItem(e.getNewSlot())); } } @EventHandler(priority = EventPriority.HIGHEST) public void onSwapHandItems(PlayerSwapHandItemsEvent e) { if (e.isCancelled()) { adjustAttackSpeed(e.getPlayer()); } else { adjustAttackSpeed(e.getPlayer(), e.getOffHandItem()); } } @EventHandler(priority = EventPriority.HIGH) public void onPlayerQuit(PlayerQuitEvent e) { setAttackSpeed(e.getPlayer(), VANILLA_ATTACK_SPEED); } /** * Adjusts the attack speed to the default or configured value, depending on * whether the module is enabled. * * @param player the player to set the attack speed for */ private void adjustAttackSpeed(Player player) { adjustAttackSpeed(player, player.getInventory().getItemInMainHand()); } private void adjustAttackSpeed(Player player, ItemStack mainHand) { final double attackSpeed = isEnabled(player) ? getConfiguredAttackSpeed(mainHand) : VANILLA_ATTACK_SPEED; setAttackSpeed(player, attackSpeed); } @Override public void onModesetChange(Player player) { adjustAttackSpeed(player); } private double getConfiguredAttackSpeed(ItemStack itemStack) { if (itemStack == null) { return genericAttackSpeed; } return heldItemAttackSpeeds.getOrDefault(itemStack.getType(), genericAttackSpeed); } /** * Sets the attack speed to the given value. * * @param player the player to set it for * @param attackSpeed the attack speed to set it to */ public void setAttackSpeed(Player player, double attackSpeed) { final AttributeInstance attribute = player.getAttribute(XAttribute.ATTACK_SPEED.get()); if (attribute == null) return; final double baseValue = attribute.getBaseValue(); if (baseValue != attackSpeed) { debug(String.format("Setting attack speed to %.2f (was: %.2f)", attackSpeed, baseValue), player); attribute.setBaseValue(attackSpeed); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleAttackFrequency.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.entity.Entity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.entity.CreatureSpawnEvent; import org.bukkit.event.entity.EntityTeleportEvent; import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerRespawnEvent; public class ModuleAttackFrequency extends OCMModule { private static final int DEFAULT_DELAY = 20; private static int playerDelay, mobDelay; public ModuleAttackFrequency(OCMMain plugin) { super(plugin, "attack-frequency"); reload(); } @Override public void reload() { playerDelay = module().getInt("playerDelay"); mobDelay = module().getInt("mobDelay"); Bukkit.getWorlds().forEach(world -> world.getLivingEntities().forEach(livingEntity -> { if (livingEntity instanceof Player) livingEntity.setMaximumNoDamageTicks(isEnabled((Player) livingEntity) ? playerDelay : DEFAULT_DELAY); else livingEntity.setMaximumNoDamageTicks(isEnabled(world) ? mobDelay : DEFAULT_DELAY); })); } @EventHandler public void onPlayerJoin(PlayerJoinEvent e) { final Player player = e.getPlayer(); if (isEnabled(player)) setDelay(player, playerDelay); } @EventHandler public void onPlayerLogout(PlayerQuitEvent e) { setDelay(e.getPlayer(), DEFAULT_DELAY); } @EventHandler public void onPlayerChangeWorld(PlayerChangedWorldEvent e) { final Player player = e.getPlayer(); setDelay(player, isEnabled(player) ? playerDelay : DEFAULT_DELAY); } @EventHandler public void onPlayerRespawn(PlayerRespawnEvent e) { final Player player = e.getPlayer(); setDelay(player, isEnabled(player) ? playerDelay : DEFAULT_DELAY); } private void setDelay(Player player, int delay) { player.setMaximumNoDamageTicks(delay); debug("Set hit delay to " + delay, player); } @EventHandler public void onCreatureSpawn(CreatureSpawnEvent e) { final LivingEntity livingEntity = e.getEntity(); final World world = livingEntity.getWorld(); if (isEnabled(world)) livingEntity.setMaximumNoDamageTicks(mobDelay); } @EventHandler public void onEntityTeleportEvent(EntityTeleportEvent e) { // This event is only fired for non-player entities final Entity entity = e.getEntity(); if (!(entity instanceof LivingEntity)) return; final LivingEntity livingEntity = (LivingEntity) entity; final World fromWorld = e.getFrom().getWorld(); final Location toLocation = e.getTo(); if(toLocation == null) return; final World toWorld = toLocation.getWorld(); if (fromWorld.getUID() != toWorld.getUID()) livingEntity.setMaximumNoDamageTicks(isEnabled(toWorld) ? mobDelay : DEFAULT_DELAY); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleAttackRange.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.entity.PlayerDeathEvent; import org.bukkit.event.player.PlayerDropItemEvent; import org.bukkit.event.player.PlayerItemHeldEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerSwapHandItemsEvent; import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.plugin.Plugin; import java.util.Arrays; import java.util.Locale; import java.util.function.Predicate; import java.lang.reflect.Method; /** * Applies the 1.8-style attack range (reach + hitbox margin) to melee weapons on 1.21.11+ Paper. * Gracefully disables itself on Spigot or older versions where the AttackRange data component is absent. */ public class ModuleAttackRange extends OCMModule implements Listener { private static final String[] WEAPONS = {"sword", "axe", "pickaxe", "spade", "shovel", "hoe", "trident", "mace"}; private boolean supported; private float minRange; private float maxRange; private float minCreative; private float maxCreative; private float hitboxMargin; private float mobFactor; private PaperAttackRangeAdapter paperAdapter; public ModuleAttackRange(OCMMain plugin) { super(plugin, "attack-range"); initialiseReflection(); registerCleanerListener(plugin); reload(); } private void initialiseReflection() { if (!Reflector.versionIsNewerOrEqualTo(1, 21, 11)) { supported = false; return; } try { paperAdapter = new PaperAttackRangeAdapter(); supported = true; } catch (Throwable t) { supported = false; Messenger.warn("Attack range component API not available (Paper 1.21.11+ required); module disabled. (" + t.getClass().getSimpleName() + ": " + t.getMessage() + ")"); } } @Override public void reload() { if (!supported) return; minRange = (float) module().getDouble("min-range", 0.0); maxRange = (float) module().getDouble("max-range", 3.0); minCreative = (float) module().getDouble("min-creative-range", 0.0); maxCreative = (float) module().getDouble("max-creative-range", 4.0); hitboxMargin = (float) module().getDouble("hitbox-margin", 0.1); mobFactor = (float) module().getDouble("mob-factor", 1.0); // Apply to currently online players so config changes take effect immediately Bukkit.getOnlinePlayers().forEach(this::applyToHeld); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onJoin(PlayerJoinEvent event) { applyToHeld(event.getPlayer()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onHotbar(PlayerItemHeldEvent event) { // strip old, then apply/strip new cleanHand(event.getPlayer(), event.getPreviousSlot()); applyToHeld(event.getPlayer()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onSwap(PlayerSwapHandItemsEvent event) { normaliseSwapEvent(event); reconcileSwapInventory(event.getPlayer()); } private void normaliseSwapEvent(PlayerSwapHandItemsEvent event) { Player player = event.getPlayer(); if (!supported) return; ItemStack postSwapMainHand = event.getOffHandItem(); ItemStack postSwapOffHand = event.getMainHandItem(); stripComponent(postSwapOffHand); applyToItem(player, postSwapMainHand); // Persist adjusted stacks into event payload for synthetic/manual swap flows. event.setOffHandItem(postSwapMainHand); event.setMainHandItem(postSwapOffHand); } private void reconcileSwapInventory(Player player) { if (!supported) return; Bukkit.getScheduler().runTask(plugin, () -> { if (!player.isOnline()) return; ItemStack mainHand = player.getInventory().getItemInMainHand(); ItemStack offHand = player.getInventory().getItemInOffHand(); stripComponent(mainHand); stripComponent(offHand); applyToItem(player, mainHand); }); } private void applyToHeld(Player player) { if (!supported) return; ItemStack item = player.getInventory().getItemInMainHand(); if (item == null || item.getType() == Material.AIR) return; applyToItem(player, item); } private void applyToItem(Player player, ItemStack item) { if (item == null || item.getType() == Material.AIR || !isWeapon(item.getType())) { stripComponent(item); return; } if (!isEnabled(player)) { stripComponent(item); return; } applyAttackRange(item); } private void cleanHand(Player player, int slot) { ItemStack old = player.getInventory().getItem(slot); stripComponent(old); } private boolean isWeapon(Material material) { final String name = material.name().toLowerCase(Locale.ROOT); return Arrays.stream(WEAPONS).anyMatch(name::endsWith); } private void applyAttackRange(ItemStack item) { paperAdapter.apply(item, minRange, maxRange, minCreative, maxCreative, hitboxMargin, mobFactor); } private void stripComponent(ItemStack item) { if (!supported || paperAdapter == null || item == null) return; paperAdapter.clear(item); } private void registerCleanerListener(Plugin plugin) { Bukkit.getPluginManager().registerEvents(new CleanerListener(), plugin); } /** * Always-on listener that strips the component when the item leaves hand or is dropped, * preventing lingering modified stacks even when the module is disabled. */ private class CleanerListener implements Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onHeldChange(PlayerItemHeldEvent event) { cleanHand(event.getPlayer(), event.getPreviousSlot()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onSwap(PlayerSwapHandItemsEvent event) { // Handled by the module listener; avoid clobbering its swap normalisation. } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onDrop(PlayerDropItemEvent event) { stripComponent(event.getItemDrop().getItemStack()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onDeath(PlayerDeathEvent event) { event.getDrops().forEach(ModuleAttackRange.this::stripComponent); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onQuit(PlayerQuitEvent event) { stripComponent(event.getPlayer().getInventory().getItemInMainHand()); stripComponent(event.getPlayer().getInventory().getItemInOffHand()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onWorldChange(PlayerChangedWorldEvent event) { stripComponent(event.getPlayer().getInventory().getItemInMainHand()); stripComponent(event.getPlayer().getInventory().getItemInOffHand()); applyToHeld(event.getPlayer()); } } /** * Paper-only adapter to avoid reflection in hot paths. */ private static class PaperAttackRangeAdapter { @SuppressWarnings("unchecked") private static final Predicate COPY_ALL_COMPONENTS = ignored -> true; private final Object attackRangeType; private final java.lang.reflect.Method attackRangeFactory; private final java.lang.reflect.Method minReachSetter; private final java.lang.reflect.Method maxReachSetter; private final java.lang.reflect.Method minCreativeSetter; private final java.lang.reflect.Method maxCreativeSetter; private final java.lang.reflect.Method hitboxSetter; private final java.lang.reflect.Method mobFactorSetter; private final java.lang.reflect.Method buildMethod; private final java.lang.reflect.Method itemSetData; private final java.lang.reflect.Method itemHasData; private final java.lang.reflect.Method itemUnsetData; private final java.lang.reflect.Method itemEnsureServerConversions; private final java.lang.reflect.Method itemCopyDataFrom; private boolean warned; PaperAttackRangeAdapter() throws Exception { Class dct = Class.forName("io.papermc.paper.datacomponent.DataComponentTypes"); Class ar = Class.forName("io.papermc.paper.datacomponent.item.AttackRange"); Class builder = Class.forName("io.papermc.paper.datacomponent.item.AttackRange$Builder"); attackRangeType = dct.getField("ATTACK_RANGE").get(null); attackRangeFactory = ar.getMethod("attackRange"); minReachSetter = builder.getMethod("minReach", float.class); maxReachSetter = builder.getMethod("maxReach", float.class); minCreativeSetter = builder.getMethod("minCreativeReach", float.class); maxCreativeSetter = builder.getMethod("maxCreativeReach", float.class); hitboxSetter = builder.getMethod("hitboxMargin", float.class); mobFactorSetter = builder.getMethod("mobFactor", float.class); buildMethod = builder.getMethod("build"); Class dctClass = Class.forName("io.papermc.paper.datacomponent.DataComponentType"); itemSetData = findSetDataMethod(dctClass, ar); itemHasData = ItemStack.class.getMethod("hasData", dctClass); itemUnsetData = ItemStack.class.getMethod("unsetData", dctClass); Method ensureMethod = null; Method copyMethod = null; try { ensureMethod = ItemStack.class.getMethod("ensureServerConversions"); copyMethod = ItemStack.class.getMethod("copyDataFrom", ItemStack.class, Predicate.class); } catch (NoSuchMethodException ignored) { // Older/newer API shape; keep as best-effort no-op. } itemEnsureServerConversions = ensureMethod; itemCopyDataFrom = copyMethod; } private Method findSetDataMethod(Class dctClass, Class valueClass) throws NoSuchMethodException { for (Method m : ItemStack.class.getMethods()) { if (!m.getName().equals("setData")) continue; Class[] params = m.getParameterTypes(); if (params.length != 2) continue; // accept any data component type class if (!dctClass.isAssignableFrom(params[0]) && !params[0].getName().contains("DataComponentType")) continue; if (!params[1].isAssignableFrom(valueClass) && !valueClass.isAssignableFrom(params[1]) && !params[1].isAssignableFrom(Object.class)) continue; return m; } throw new NoSuchMethodException(ItemStack.class.getName() + "#setData(DataComponentType, AttackRange)"); } void apply(ItemStack stack, float min, float max, float minCreative, float maxCreative, float margin, float mobFactor) { try { Object builder = attackRangeFactory.invoke(null); invokeSetter(minReachSetter, builder, min); invokeSetter(maxReachSetter, builder, max); invokeSetter(minCreativeSetter, builder, minCreative); invokeSetter(maxCreativeSetter, builder, maxCreative); invokeSetter(hitboxSetter, builder, margin); invokeSetter(mobFactorSetter, builder, mobFactor); Object arObj = buildMethod.invoke(builder); itemSetData.invoke(stack, attackRangeType, arObj); ensureServerConversions(stack); } catch (Throwable t) { if (!warned) { Messenger.warn("Attack range component application failed; leaving item unchanged. (" + t.getClass().getSimpleName() + ": " + t.getMessage() + ")"); warned = true; } } } private void invokeSetter(Method setter, Object builder, float value) throws Exception { Object result = setter.invoke(builder, value); if (result != null && !setter.getReturnType().equals(void.class) && !setter.getReturnType().equals(Void.class)) { // Some Paper versions return the builder for chaining; others mutate in place. // We do not need to capture the returned value because all calls target the same instance. } } boolean hasComponent(ItemStack stack) { try { return (boolean) itemHasData.invoke(stack, attackRangeType); } catch (Throwable t) { return false; } } void clear(ItemStack stack) { try { if (hasComponent(stack)) { itemUnsetData.invoke(stack, attackRangeType); ensureServerConversions(stack); } } catch (Throwable ignored) { // ignore } } private void ensureServerConversions(ItemStack stack) { if (stack == null || itemEnsureServerConversions == null || itemCopyDataFrom == null) return; try { Object converted = itemEnsureServerConversions.invoke(stack); if (!(converted instanceof ItemStack)) return; if (converted == stack) return; itemCopyDataFrom.invoke(stack, converted, COPY_ALL_COMPONENTS); } catch (Throwable ignored) { // no-op: best-effort sync only } } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleAttackSounds.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.github.retrooper.packetevents.PacketEvents; import com.github.retrooper.packetevents.event.PacketListenerAbstract; import com.github.retrooper.packetevents.event.PacketSendEvent; import com.github.retrooper.packetevents.protocol.packettype.PacketType; import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerSoundEffect; import com.cryptomorin.xseries.XSound; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.Sound; import org.bukkit.entity.Player; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Optional; import java.util.Set; import java.lang.reflect.Method; /** * A module to disable the new attack sounds. */ public class ModuleAttackSounds extends OCMModule { private final SoundListener soundListener = new SoundListener(); private final Set blockedSounds = new HashSet<>(); public ModuleAttackSounds(OCMMain plugin) { super(plugin, "disable-attack-sounds"); reload(); } @Override public void reload() { blockedSounds.clear(); blockedSounds.addAll(getBlockedSounds()); if (isEnabled() && !blockedSounds.isEmpty()) PacketEvents.getAPI().getEventManager().registerListener(soundListener); else PacketEvents.getAPI().getEventManager().unregisterListener(soundListener); } private Collection getBlockedSounds() { List fromConfig = module().getStringList("blocked-sound-names"); Set processed = new HashSet<>(); for (String soundName : fromConfig) { Optional xSound = XSound.matchXSound(soundName); if (xSound.isPresent()) { Sound sound = xSound.get().parseSound(); if (sound != null) { // On modern versions, we can get the namespaced key directly try { Method getKeyMethod = Sound.class.getMethod("getKey"); Object key = getKeyMethod.invoke(sound); processed.add(key.toString()); continue; } catch (Exception ignored) { // This server version doesn't have the getKey method, so we fall back to the // legacy name } } // Fallback for older versions or if the sound is not in the Bukkit enum String processedName = soundName.toLowerCase(Locale.ROOT).replace('_', '.'); if (!processedName.contains(":")) { processedName = "minecraft:" + processedName; } processed.add(processedName); } else { Messenger.warn("Invalid sound name in config: " + soundName); } } return processed; } /** * Disables attack sounds. */ private class SoundListener extends PacketListenerAbstract { private boolean disabledDueToError; @Override public void onPacketSend(PacketSendEvent packetEvent) { if (disabledDueToError || packetEvent.isCancelled()) return; if (blockedSounds.isEmpty()) return; final Object playerObject = packetEvent.getPlayer(); if (!(playerObject instanceof Player)) return; final Player player = (Player) playerObject; if (!isEnabled(player)) return; final Object packetType = packetEvent.getPacketType(); if (!PacketType.Play.Server.NAMED_SOUND_EFFECT.equals(packetType) && !PacketType.Play.Server.SOUND_EFFECT.equals(packetType)) { return; } try { WrapperPlayServerSoundEffect wrapper = new WrapperPlayServerSoundEffect(packetEvent); com.github.retrooper.packetevents.protocol.sound.Sound sound = wrapper.getSound(); if (sound == null || sound.getSoundId() == null) return; String soundName = sound.getSoundId().toString(); if (blockedSounds.contains(soundName)) { packetEvent.setCancelled(true); debug("Blocked sound " + soundName, player); } } catch (Exception | ExceptionInInitializerError e) { disabledDueToError = true; Messenger.warn( e, "Error detecting sound packets. Please report it along with the following exception " + "on github."); } } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleChorusFruit.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.MathsHelper; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.World; import org.bukkit.block.Block; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.player.PlayerItemConsumeEvent; import org.bukkit.event.player.PlayerTeleportEvent; import org.bukkit.block.BlockFace; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import java.util.concurrent.ThreadLocalRandom; /** * A module to control chorus fruits. */ public class ModuleChorusFruit extends OCMModule { public ModuleChorusFruit(OCMMain plugin) { super(plugin, "chorus-fruit"); } @EventHandler public void onEat(PlayerItemConsumeEvent e) { if (e.getItem().getType() != Material.CHORUS_FRUIT) return; final Player player = e.getPlayer(); if (!isEnabled(player)) return; if (module().getBoolean("prevent-eating")) { e.setCancelled(true); return; } final int hungerValue = module().getInt("hunger-value"); final double saturationValue = module().getDouble("saturation-value"); final int previousFoodLevel = player.getFoodLevel(); final float previousSaturation = player.getSaturation(); // Run it on the next tick to reset things while not cancelling the chorus fruit eat event // This ensures the teleport event is fired and counts towards statistics Bukkit.getScheduler().runTaskLater(plugin, () -> { final int newFoodLevel = Math.min(hungerValue + previousFoodLevel, 20); final float newSaturation = Math.min((float) (saturationValue + previousSaturation), newFoodLevel); player.setFoodLevel(newFoodLevel); player.setSaturation(newSaturation); debug("Food level changed from: " + previousFoodLevel + " to " + player.getFoodLevel(), player); }, 2L); } @EventHandler public void onTeleport(PlayerTeleportEvent e) { if (e.getCause() != PlayerTeleportEvent.TeleportCause.CHORUS_FRUIT) return; final Player player = e.getPlayer(); if (!isEnabled(player)) return; final double distance = getMaxTeleportationDistance(); if (distance == 8) { debug("Using vanilla teleport implementation!", player); return; } if (distance <= 0) { debug("Chorus teleportation is not allowed", player); e.setCancelled(true); return; } // Not sure when this can occur, but it is marked as @Nullable final Location toLocation = e.getTo(); if (toLocation == null) { debug("Teleport target is null", player); return; } final int maxheight = toLocation.getWorld().getMaxHeight(); final Location origin = player.getLocation(); final World world = origin.getWorld(); final ThreadLocalRandom rng = ThreadLocalRandom.current(); Location chosen = null; // Mirror vanilla chorus fruit: up to 16 attempts to find a safe spot for (int i = 0; i < 16; i++) { final double x = origin.getX() + (rng.nextDouble() - 0.5D) * 2 * distance; final double y = MathsHelper.clamp(origin.getY() + rng.nextInt(Math.max(1, (int) Math.ceil(distance))), 0, maxheight - 1); final double z = origin.getZ() + (rng.nextDouble() - 0.5D) * 2 * distance; final Location candidate = new Location(world, x, y, z); if (!world.getWorldBorder().isInside(candidate)) continue; if (!isSafe(candidate)) continue; chosen = candidate; break; } if (chosen == null) { debug("No safe chorus teleport found within distance " + distance + ", keeping vanilla target", player); return; } e.setTo(chosen); debug("Chorus teleport redirected to safe location " + chosen, player); } private double getMaxTeleportationDistance() { return module().getDouble("max-teleportation-distance"); } private boolean isSafe(Location location) { Block feet = location.getBlock(); Block head = feet.getRelative(BlockFace.UP); Block below = feet.getRelative(BlockFace.DOWN); boolean modern = Reflector.versionIsNewerOrEqualTo(1, 13, 0); boolean feetPassable = modern ? feet.isPassable() : !feet.getType().isSolid(); boolean headPassable = modern ? head.isPassable() : !head.getType().isSolid(); if (!feetPassable || !headPassable) return false; if (!below.getType().isSolid()) return false; return true; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleDisableCrafting.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.ConfigUtils; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.Material; import org.bukkit.entity.HumanEntity; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.inventory.PrepareItemCraftEvent; import org.bukkit.inventory.CraftingInventory; import org.bukkit.inventory.ItemStack; import java.util.List; /** * Makes the specified materials uncraftable. */ public class ModuleDisableCrafting extends OCMModule { private List denied; private String message; public ModuleDisableCrafting(OCMMain plugin) { super(plugin, "disable-crafting"); reload(); } @Override public void reload() { denied = ConfigUtils.loadMaterialList(module(), "denied"); message = module().getBoolean("showMessage") ? module().getString("message") : null; } @EventHandler(priority = EventPriority.HIGHEST) public void onPrepareItemCraft(PrepareItemCraftEvent e) { final List viewers = e.getViewers(); if (viewers.size() == 0) return; if (!isEnabled(viewers.get(0))) return; final CraftingInventory inv = e.getInventory(); final ItemStack result = inv.getResult(); if (result != null && denied.contains(result.getType())) { inv.setResult(null); if (message != null) viewers.forEach(viewer -> Messenger.send(viewer, message)); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleDisableEnderpearlCooldown.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.GameMode; import org.bukkit.Material; import org.bukkit.entity.EnderPearl; import org.bukkit.entity.Player; import org.bukkit.entity.Projectile; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.ProjectileLaunchEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.PlayerInventory; import org.bukkit.projectiles.ProjectileSource; import java.util.*; /** * Allows you to throw enderpearls as often as you like, not only after a cooldown. */ public class ModuleDisableEnderpearlCooldown extends OCMModule { /** * Contains players that threw an ender pearl. As the handler calls launchProjectile, * which also calls ProjectileLaunchEvent, we need to ignore that event call. */ private final Set ignoredPlayers = new HashSet<>(); private Map lastLaunched; private int cooldown; private String message; private static ModuleDisableEnderpearlCooldown INSTANCE; public ModuleDisableEnderpearlCooldown(OCMMain plugin) { super(plugin, "disable-enderpearl-cooldown"); INSTANCE = this; reload(); } public void reload() { cooldown = module().getInt("cooldown"); if (cooldown > 0) { // Performance/correctness: // - Use a normal HashMap; WeakHashMap can drop entries unpredictably. // - Avoid a recurring cleanup task: expired entries are dropped lazily during checks. if (lastLaunched == null) lastLaunched = new HashMap<>(); } else lastLaunched = null; message = module().getBoolean("showMessage") ? module().getString("message") : null; } public static ModuleDisableEnderpearlCooldown getInstance() { return INSTANCE; } @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerShoot(ProjectileLaunchEvent e) { if (e.isCancelled()) return; // For compatibility with other plugins final Projectile projectile = e.getEntity(); if (!(projectile instanceof EnderPearl)) return; final ProjectileSource shooter = projectile.getShooter(); if (!(shooter instanceof Player)) return; final Player player = (Player) shooter; if (!isEnabled(player)) return; final UUID uuid = player.getUniqueId(); if (ignoredPlayers.contains(uuid)) return; e.setCancelled(true); // Check if the cooldown has expired yet if (lastLaunched != null) { // Intentionally wall-clock driven: enderpearl cooldowns are typically expected to be real-time, even // when TPS drops, unlike 1.8 natural regen which is tick based. final long currentTime = System.currentTimeMillis() / 1000; if (lastLaunched.containsKey(uuid)) { final long elapsedSeconds = currentTime - lastLaunched.get(uuid); if (elapsedSeconds < cooldown) { if (message != null) Messenger.send(player, message, cooldown - elapsedSeconds); return; } // Lazy expiry cleanup to keep the map bounded without a recurring task. lastLaunched.remove(uuid); } lastLaunched.put(uuid, currentTime); } // Make sure we ignore the event triggered by launchProjectile ignoredPlayers.add(uuid); final EnderPearl pearl = player.launchProjectile(EnderPearl.class); ignoredPlayers.remove(uuid); pearl.setVelocity(player.getEyeLocation().getDirection().multiply(2)); if (player.getGameMode() == GameMode.CREATIVE) return; final ItemStack enderpearlItemStack; final PlayerInventory playerInventory = player.getInventory(); final ItemStack mainHand = playerInventory.getItemInMainHand(); final ItemStack offHand = playerInventory.getItemInOffHand(); if (isEnderPearl(mainHand)) enderpearlItemStack = mainHand; else if (isEnderPearl(offHand)) enderpearlItemStack = offHand; else return; enderpearlItemStack.setAmount(enderpearlItemStack.getAmount() - 1); } private boolean isEnderPearl(ItemStack itemStack) { return itemStack != null && itemStack.getType() == Material.ENDER_PEARL; } @EventHandler public void onPlayerQuit(PlayerQuitEvent e) { if (lastLaunched != null) lastLaunched.remove(e.getPlayer().getUniqueId()); } /** * Get the remaining cooldown time for ender pearls for a given player. * @param playerUUID The UUID of the player to check the cooldown for. * @return The remaining cooldown time in seconds, or 0 if there is no cooldown or it has expired. */ public long getEnderpearlCooldown(UUID playerUUID) { if (lastLaunched != null && lastLaunched.containsKey(playerUUID)) { final long currentTime = System.currentTimeMillis() / 1000; // Current time in seconds final long lastLaunchTime = lastLaunched.get(playerUUID); // Last launch time in seconds final long elapsedSeconds = currentTime - lastLaunchTime; final long cooldownRemaining = cooldown - elapsedSeconds; if (cooldownRemaining <= 0) { // Lazy expiry cleanup: if the cooldown has elapsed, drop the entry. lastLaunched.remove(playerUUID); return 0; } return Math.max(cooldownRemaining, 0); // Return the remaining cooldown or 0 if it has expired } return 0; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleDisableOffHand.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.ConfigUtils; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.Material; import org.bukkit.command.CommandSender; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.inventory.ClickType; import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryDragEvent; import org.bukkit.event.inventory.InventoryType; import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.event.player.PlayerSwapHandItemsEvent; import org.bukkit.inventory.Inventory; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.PlayerInventory; import java.lang.reflect.Method; import java.util.Collection; import java.util.List; import java.util.function.BiPredicate; /** * Disables usage of the off-hand. */ public class ModuleDisableOffHand extends OCMModule { private static final int OFFHAND_SLOT = 40; private List materials; private String deniedMessage; private BlockType blockType; // Cache reflective methods used on older versions private static volatile boolean useReflectionViewPath = false; private static Method getViewMethod; private static Method getBottomInventoryMethod; private static Method getTopInventoryMethod; public ModuleDisableOffHand(OCMMain plugin) { super(plugin, "disable-offhand"); reload(); } @Override public void reload() { blockType = module().getBoolean("whitelist") ? BlockType.WHITELIST : BlockType.BLACKLIST; materials = ConfigUtils.loadMaterialList(module(), "items"); deniedMessage = module().getString("denied-message"); } private void sendDeniedMessage(CommandSender sender) { if (!deniedMessage.trim().isEmpty()) Messenger.send(sender, deniedMessage); } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onSwapHandItems(PlayerSwapHandItemsEvent e) { final Player player = e.getPlayer(); if (isEnabled(player) && isItemBlocked(e.getOffHandItem())) { e.setCancelled(true); sendDeniedMessage(player); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryClick(InventoryClickEvent e) { final HumanEntity player = e.getWhoClicked(); if (!isEnabled(player)) return; final ClickType clickType = e.getClick(); try { if (clickType == ClickType.SWAP_OFFHAND) { e.setResult(Event.Result.DENY); sendDeniedMessage(player); return; } } catch (NoSuchFieldError ignored) { } // For versions below 1.16 final Inventory clickedInventory = e.getClickedInventory(); if (clickedInventory == null) return; final InventoryType inventoryType = clickedInventory.getType(); // Source inventory must be PLAYER if (inventoryType != InventoryType.PLAYER) return; // First try the modern Bukkit API path. If that fails once (older versions), // fall back to a cached reflection path next time onwards. if (!useReflectionViewPath) { try { final Inventory bottom = e.getView().getBottomInventory(); final Inventory top = e.getView().getTopInventory(); if (bottom.getType() != InventoryType.CRAFTING && top.getType() != InventoryType.CRAFTING) return; } catch (Throwable ignored) { useReflectionViewPath = true; } } if (useReflectionViewPath) { try { if (getViewMethod == null) { getViewMethod = Reflector.getMethod(e.getClass(), "getView"); } final Object view = Reflector.invokeMethod(getViewMethod, e); final Class viewClass = view.getClass(); if (getBottomInventoryMethod == null) { getBottomInventoryMethod = Reflector.getMethod(viewClass, "getBottomInventory"); } if (getTopInventoryMethod == null) { getTopInventoryMethod = Reflector.getMethod(viewClass, "getTopInventory"); } final Inventory bottom = Reflector.invokeMethod(getBottomInventoryMethod, view); final Inventory top = Reflector.invokeMethod(getTopInventoryMethod, view); if (bottom.getType() != InventoryType.CRAFTING && top.getType() != InventoryType.CRAFTING) return; } catch (RuntimeException exception) { exception.printStackTrace(); } } // Prevent shift-clicking a shield into the offhand item slot final ItemStack currentItem = e.getCurrentItem(); if (currentItem != null && currentItem.getType() == Material.SHIELD && isItemBlocked(currentItem) && e.getSlot() != OFFHAND_SLOT && e.isShiftClick()) { e.setResult(Event.Result.DENY); sendDeniedMessage(player); } if (e.getSlot() == OFFHAND_SLOT && ((clickType == ClickType.NUMBER_KEY && isItemBlocked(clickedInventory.getItem(e.getHotbarButton()))) || isItemBlocked(e.getCursor()))) { e.setResult(Event.Result.DENY); sendDeniedMessage(player); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInventoryDrag(InventoryDragEvent e) { final HumanEntity player = e.getWhoClicked(); if (!isEnabled(player) || e.getInventory().getType() != InventoryType.CRAFTING || !e.getInventorySlots().contains(OFFHAND_SLOT)) return; if (isItemBlocked(e.getOldCursor())) { e.setResult(Event.Result.DENY); sendDeniedMessage(player); } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onWorldChange(PlayerChangedWorldEvent e) { onModesetChange(e.getPlayer()); } @Override public void onModesetChange(Player player) { if (!isEnabled(player)) return; final PlayerInventory inventory = player.getInventory(); final ItemStack offHandItem = inventory.getItemInOffHand(); if (isItemBlocked(offHandItem)) { sendDeniedMessage(player); inventory.setItemInOffHand(new ItemStack(Material.AIR)); if (!inventory.addItem(offHandItem).isEmpty()) player.getWorld().dropItemNaturally(player.getLocation(), offHandItem); } } private boolean isItemBlocked(ItemStack item) { if (item == null || item.getType() == Material.AIR) { return false; } return !blockType.isAllowed(materials, item.getType()); } private enum BlockType { WHITELIST(Collection::contains), BLACKLIST(not(Collection::contains)); private final BiPredicate, Material> filter; BlockType(BiPredicate, Material> filter) { this.filter = filter; } /** * Checks whether the given material is allowed. * * @param list the list to use for checking * @param toCheck the material to check * @return true if the item is allowed, based on the list and the current mode */ boolean isAllowed(Collection list, Material toCheck) { return filter.test(list, toCheck); } } private static BiPredicate not(BiPredicate predicate) { return predicate.negate(); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleFishingKnockback.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import com.cryptomorin.xseries.XEntityType; import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser; import org.bukkit.GameMode; import org.bukkit.Location; import org.bukkit.entity.*; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.ProjectileHitEvent; import org.bukkit.event.player.PlayerFishEvent; import org.bukkit.util.Vector; /** * Brings back the old fishing-rod knockback. */ public class ModuleFishingKnockback extends OCMModule { private final SpigotFunctionChooser getHookFunction; private final SpigotFunctionChooser getHitEntityFunction; private boolean knockbackNonPlayerEntities; public ModuleFishingKnockback(OCMMain plugin) { super(plugin, "old-fishing-knockback"); reload(); getHookFunction = SpigotFunctionChooser.apiCompatReflectionCall((e, params) -> e.getHook(), PlayerFishEvent.class, "getHook"); getHitEntityFunction = SpigotFunctionChooser.apiCompatCall((e, params) -> e.getHitEntity(), (e, params) -> { final Entity hookEntity = e.getEntity(); return hookEntity.getWorld().getNearbyEntities(hookEntity.getLocation(), 0.25, 0.25, 0.25).stream() .filter(entity -> !knockbackNonPlayerEntities && entity instanceof Player) .findFirst() .orElse(null); }); } @Override public void reload() { knockbackNonPlayerEntities = isSettingEnabled("knockbackNonPlayerEntities"); } @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void onRodLand(ProjectileHitEvent event) { final Entity hookEntity = event.getEntity(); final EntityType fishingBobberType = XEntityType.FISHING_BOBBER.get(); if (fishingBobberType == null || event.getEntityType() != fishingBobberType) return; final FishHook hook = (FishHook) hookEntity; if (!(hook.getShooter() instanceof Player)) return; final Player rodder = (Player) hook.getShooter(); if (!isEnabled(rodder)) return; final Entity hitEntity = getHitEntityFunction.apply(event); if (hitEntity == null) return; // If no entity was hit if (!(hitEntity instanceof LivingEntity)) return; final LivingEntity livingEntity = (LivingEntity) hitEntity; if (!knockbackNonPlayerEntities && !(hitEntity instanceof Player)) return; // Do not move Citizens NPCs // See https://wiki.citizensnpcs.co/API#Checking_if_an_entity_is_a_Citizens_NPC if (hitEntity.hasMetadata("NPC")) return; if (!knockbackNonPlayerEntities) { final Player player = (Player) hitEntity; debug("You were hit by a fishing rod!", player); if (player.equals(rodder)) return; if (player.getGameMode() == GameMode.CREATIVE) return; } // Check if cooldown time has elapsed if (livingEntity.getNoDamageTicks() > livingEntity.getMaximumNoDamageTicks() / 2f) return; double damage = module().getDouble("damage"); if (damage < 0) damage = 0.0001; livingEntity.damage(damage, rodder); livingEntity.setVelocity( calculateKnockbackVelocity(livingEntity.getVelocity(), livingEntity.getLocation(), hook.getLocation())); } private Vector calculateKnockbackVelocity(Vector currentVelocity, Location player, Location hook) { double xDistance = hook.getX() - player.getX(); double zDistance = hook.getZ() - player.getZ(); // ensure distance is not zero and randomise in that case (I guess?) while (xDistance * xDistance + zDistance * zDistance < 0.0001) { xDistance = (Math.random() - Math.random()) * 0.01D; zDistance = (Math.random() - Math.random()) * 0.01D; } final double distance = Math.sqrt(xDistance * xDistance + zDistance * zDistance); double y = currentVelocity.getY() / 2; double x = currentVelocity.getX() / 2; double z = currentVelocity.getZ() / 2; // Normalise distance to have similar knockback, no matter the distance x -= xDistance / distance * 0.4; // slow the fall or throw upwards y += 0.4; // Normalise distance to have similar knockback, no matter the distance z -= zDistance / distance * 0.4; // do not shoot too high up if (y >= 0.4) y = 0.4; return new Vector(x, y, z); } /** * This is to cancel dragging the entity closer when you reel in */ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) private void onReelIn(PlayerFishEvent e) { if (e.getState() != PlayerFishEvent.State.CAUGHT_ENTITY) return; if (!isEnabled(e.getPlayer())) return; final String cancelDraggingIn = module().getString("cancelDraggingIn", "players"); final boolean isPlayer = e.getCaught() instanceof HumanEntity; if ((cancelDraggingIn.equals("players") && isPlayer) || cancelDraggingIn.equals("mobs") && !isPlayer || cancelDraggingIn.equals("all")) { getHookFunction.apply(e).remove(); // Remove the bobber and don't do anything else e.setCancelled(true); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleFishingRodVelocity.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.entity.FishHook; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.player.PlayerFishEvent; import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.util.Vector; import java.util.HashSet; import java.util.Iterator; import java.util.Random; import java.util.Set; /** * This module reverts fishing rod gravity and velocity back to 1.8 behaviour *

* Fishing rod gravity in 1.14+ is 0.03 while in 1.8 it is 0.04 * Launch velocity in 1.9+ is also different from the 1.8 formula */ public class ModuleFishingRodVelocity extends OCMModule { private Random random; private boolean hasDifferentGravity; private final Set activeHooks = new HashSet<>(); private BukkitRunnable gravityTask; // In 1.12- getHook() returns a Fish which extends FishHook private final SpigotFunctionChooser getHook = SpigotFunctionChooser.apiCompatReflectionCall( (e, params) -> e.getHook(), PlayerFishEvent.class, "getHook" ); public ModuleFishingRodVelocity(OCMMain plugin) { super(plugin, "fishing-rod-velocity"); reload(); } @Override public void reload() { random = new Random(); // Versions 1.14+ have different gravity than previous versions hasDifferentGravity = Reflector.versionIsNewerOrEqualTo(1, 14, 0); if (gravityTask != null) { gravityTask.cancel(); gravityTask = null; } activeHooks.clear(); } @EventHandler (ignoreCancelled = true) public void onFishEvent(PlayerFishEvent event) { final FishHook fishHook = getHook.apply(event); final Player player = event.getPlayer(); if (!isEnabled(player) || event.getState() != PlayerFishEvent.State.FISHING) return; final Location location = event.getPlayer().getLocation(); final double playerYaw = location.getYaw(); final double playerPitch = location.getPitch(); final float oldMaxVelocity = 0.4F; double velocityX = -Math.sin(playerYaw / 180.0F * (float) Math.PI) * Math.cos(playerPitch / 180.0F * (float) Math.PI) * oldMaxVelocity; double velocityZ = Math.cos(playerYaw / 180.0F * (float) Math.PI) * Math.cos(playerPitch / 180.0F * (float) Math.PI) * oldMaxVelocity; double velocityY = -Math.sin(playerPitch / 180.0F * (float) Math.PI) * oldMaxVelocity; final double oldVelocityMultiplier = 1.5; final double vectorLength = (float) Math.sqrt(velocityX * velocityX + velocityY * velocityY + velocityZ * velocityZ); velocityX /= vectorLength; velocityY /= vectorLength; velocityZ /= vectorLength; velocityX += random.nextGaussian() * 0.007499999832361937D; velocityY += random.nextGaussian() * 0.007499999832361937D; velocityZ += random.nextGaussian() * 0.007499999832361937D; velocityX *= oldVelocityMultiplier; velocityY *= oldVelocityMultiplier; velocityZ *= oldVelocityMultiplier; fishHook.setVelocity(new Vector(velocityX, velocityY, velocityZ)); if (!hasDifferentGravity) return; // Adjust gravity on every tick unless it's in water. // Performance: on 1.14+ this used to schedule one repeating task per cast/hook. When players spam rods, // that can create lots of concurrent scheduled tasks. Instead, keep a set of active hooks and run one // shared per-tick task only while the set is non-empty. The work is still O(active hooks), but we avoid // scheduler overhead and per-hook task allocations. activeHooks.add(fishHook); ensureGravityTask(); } private void ensureGravityTask() { if (gravityTask != null) return; gravityTask = new BukkitRunnable() { @Override public void run() { // Stop the task as soon as it is not needed (no active hooks) to avoid a permanent every-tick cost. if (activeHooks.isEmpty()) { cancel(); gravityTask = null; return; } final Iterator it = activeHooks.iterator(); while (it.hasNext()) { final FishHook hook = it.next(); if (hook == null || !hook.isValid() || hook.isOnGround()) { it.remove(); continue; } // We check both conditions as sometimes it's underwater but in seagrass, or when bobbing not underwater but the material is water if (!hook.isInWater() && hook.getWorld().getBlockAt(hook.getLocation()).getType() != Material.WATER) { final Vector fVelocity = hook.getVelocity(); fVelocity.setY(fVelocity.getY() - 0.01); hook.setVelocity(fVelocity); } } if (activeHooks.isEmpty()) { cancel(); gravityTask = null; } } }; gravityTask.runTaskTimer(plugin, 1, 1); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleGoldenApple.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.google.common.collect.ImmutableSet; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import com.cryptomorin.xseries.XMaterial; import com.cryptomorin.xseries.XPotion; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.inventory.PrepareItemCraftEvent; import org.bukkit.event.player.PlayerItemConsumeEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ShapedRecipe; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import java.time.Duration; import java.time.Instant; import java.time.temporal.ChronoUnit; import java.util.*; /** * Customise the golden apple effects. */ public class ModuleGoldenApple extends OCMModule { // Default apple effects // Gapple: absorption I, regen II private static final Set gappleEffects = ImmutableSet.of(PotionEffectType.ABSORPTION, PotionEffectType.REGENERATION); // Napple: absorption IV, regen II, fire resistance I, resistance I private static final Set nappleEffects = ImmutableSet.of(PotionEffectType.ABSORPTION, PotionEffectType.REGENERATION, PotionEffectType.FIRE_RESISTANCE, XPotion.RESISTANCE.get()); private static final XMaterial ENCHANTED_GOLDEN_APPLE = XMaterial.ENCHANTED_GOLDEN_APPLE; private List enchantedGoldenAppleEffects, goldenAppleEffects; private ShapedRecipe enchantedAppleRecipe; private final Set warnedUnknownEffectTypes = new HashSet<>(); private Map lastEaten; private Cooldown cooldown; private String normalCooldownMessage, enchantedCooldownMessage; private static ModuleGoldenApple INSTANCE; public ModuleGoldenApple(OCMMain plugin) { super(plugin, "old-golden-apples"); INSTANCE = this; } @SuppressWarnings("deprecated") @Override public void reload() { normalCooldownMessage = module().getString("cooldown.message-normal"); enchantedCooldownMessage = module().getString("cooldown.message-enchanted"); cooldown = new Cooldown( module().getLong("cooldown.normal"), module().getLong("cooldown.enchanted"), module().getBoolean("cooldown.is-shared")); lastEaten = new WeakHashMap<>(); enchantedGoldenAppleEffects = getPotionEffects("enchanted-golden-apple-effects"); goldenAppleEffects = getPotionEffects("golden-apple-effects"); try { enchantedAppleRecipe = new ShapedRecipe( new NamespacedKey(plugin, "MINECRAFT"), createEnchantedGoldenApple()); } catch (NoClassDefFoundError e) { enchantedAppleRecipe = new ShapedRecipe(createEnchantedGoldenApple()); } enchantedAppleRecipe .shape("ggg", "gag", "ggg") .setIngredient('g', Material.GOLD_BLOCK) .setIngredient('a', Material.APPLE); registerCrafting(); } public static ModuleGoldenApple getInstance() { return ModuleGoldenApple.INSTANCE; } private void registerCrafting() { if (isEnabled() && module().getBoolean("enchanted-golden-apple-crafting")) { if (!Bukkit.getRecipesFor(createEnchantedGoldenApple()).isEmpty()) return; Bukkit.addRecipe(enchantedAppleRecipe); debug("Added napple recipe"); } } @EventHandler(priority = EventPriority.HIGH) public void onPrepareItemCraft(PrepareItemCraftEvent e) { final ItemStack item = e.getInventory().getResult(); if (item == null) return; // This should never ever ever ever run. If it does then you probably screwed // something up. if (isEnchantedGoldenApple(item)) { final List viewers = e.getInventory().getViewers(); if (viewers.isEmpty()) return; final HumanEntity player = viewers.get(0); if (isSettingEnabled("no-conflict-mode")) return; if (!isEnabled(player) || !isSettingEnabled("enchanted-golden-apple-crafting")) e.getInventory().setResult(null); } } // Intentionally avoid InventoryView#getPlayer() to prevent class/interface mismatch on 1.12. @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onItemConsume(PlayerItemConsumeEvent e) { final Player player = e.getPlayer(); if (!isEnabled(player)) return; final ItemStack originalItem = e.getItem(); final Material consumedMaterial = originalItem.getType(); if (consumedMaterial != Material.GOLDEN_APPLE && !isEnchantedGoldenApple(originalItem)) return; final UUID uuid = player.getUniqueId(); // Check if the cooldown has expired yet lastEaten.putIfAbsent(uuid, new LastEaten()); // If on cooldown send appropriate cooldown message if (cooldown.isOnCooldown(originalItem, lastEaten.get(uuid))) { final LastEaten le = lastEaten.get(uuid); final long baseCooldown; Instant current; final String message; if (consumedMaterial == Material.GOLDEN_APPLE) { baseCooldown = cooldown.normal; current = le.lastNormalEaten; message = normalCooldownMessage; } else { baseCooldown = cooldown.enchanted; current = le.lastEnchantedEaten; message = enchantedCooldownMessage; } final Optional newestEatTime = le.getNewestEatTime(); if (cooldown.sharedCooldown && newestEatTime.isPresent()) current = newestEatTime.get(); final long seconds = baseCooldown - (Instant.now().getEpochSecond() - current.getEpochSecond()); if (message != null && !message.isEmpty()) Messenger.send(player, message.replaceAll("%seconds%", String.valueOf(seconds))); e.setCancelled(true); return; } lastEaten.get(uuid).setForItem(originalItem); if (!isSettingEnabled("old-potion-effects")) return; // Save player's current potion effects final Collection previousPotionEffects = player.getActivePotionEffects(); final List newEffects = isEnchantedGoldenApple(originalItem) ? enchantedGoldenAppleEffects : goldenAppleEffects; final Set defaultEffects = isEnchantedGoldenApple(originalItem) ? nappleEffects : gappleEffects; Bukkit.getScheduler().runTaskLater(plugin, () -> { // Remove all potion effects the apple added player.getActivePotionEffects().stream() .map(PotionEffect::getType) .filter(defaultEffects::contains) .forEach(player::removePotionEffect); // Add previous potion effects from before eating the apple player.addPotionEffects(previousPotionEffects); // Add new custom effects from eating the apple applyEffects(player, newEffects); }, 1L); } private void applyEffects(LivingEntity target, List newEffects) { final boolean forceOverride = !kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector .versionIsNewerOrEqualTo(1, 13, 0); for (PotionEffect newEffect : newEffects) { // Find the existing effect of the same type with the highest amplifier final PotionEffect highestExistingEffect = target.getActivePotionEffects().stream() .filter(e -> e.getType() == newEffect.getType()) .max(Comparator.comparingInt(PotionEffect::getAmplifier)) .orElse(null); if (highestExistingEffect != null) { // If the new effect has a higher amplifier, apply it if (newEffect.getAmplifier() > highestExistingEffect.getAmplifier()) { if (forceOverride) { target.addPotionEffect(newEffect, true); } else { target.addPotionEffect(newEffect); } } // If the amplifiers are the same and the new effect has a longer duration, // refresh the duration else if (newEffect.getAmplifier() == highestExistingEffect.getAmplifier() && newEffect.getDuration() > highestExistingEffect.getDuration()) { if (forceOverride) { target.addPotionEffect(newEffect, true); } else { target.addPotionEffect(newEffect); } } // If the new effect has a lower amplifier or shorter/equal duration, do nothing } else { // If there is no existing effect of the same type, apply the new effect target.addPotionEffect(newEffect); } } } @SuppressWarnings("deprecation") private ItemStack createEnchantedGoldenApple() { final ItemStack parsed = ENCHANTED_GOLDEN_APPLE.parseItem(); if (parsed != null) { return parsed; } final ItemStack legacy = new ItemStack(Material.GOLDEN_APPLE, 1); legacy.setDurability((short) 1); return legacy; } private boolean isEnchantedGoldenApple(ItemStack item) { return item != null && ENCHANTED_GOLDEN_APPLE.isSimilar(item); } private List getPotionEffects(String path) { final List appleEffects = new ArrayList<>(); final ConfigurationSection sect = module().getConfigurationSection(path); for (String key : sect.getKeys(false)) { final int duration = sect.getInt(key + ".duration") * 20; // Convert seconds to ticks final int amplifier = sect.getInt(key + ".amplifier"); final PotionEffectType type = XPotion.matchXPotion(key) .map(XPotion::get) .orElse(null); if (type == null) { if (warnedUnknownEffectTypes.add(key)) { Messenger.warn("[%s] Unknown potion effect '%s' in %s; skipping", getModuleName(), key, path); } continue; } final PotionEffect fx = new PotionEffect(type, duration, amplifier); appleEffects.add(fx); } return appleEffects; } @EventHandler public void onPlayerQuit(PlayerQuitEvent e) { final UUID uuid = e.getPlayer().getUniqueId(); if (lastEaten != null) lastEaten.remove(uuid); } /** * Get player's current golden apple cooldown * * @param playerUUID The UUID of the player to check the cooldown for. * @return The remaining cooldown time in seconds, or 0 if there is no cooldown, * or it has expired. */ public long getGappleCooldown(UUID playerUUID) { final LastEaten lastEatenInfo = lastEaten.get(playerUUID); if (lastEatenInfo != null && lastEatenInfo.lastNormalEaten != null) { long timeElapsedSinceEaten = Duration.between(lastEatenInfo.lastNormalEaten, Instant.now()).getSeconds(); long cooldownRemaining = cooldown.normal - timeElapsedSinceEaten; return Math.max(cooldownRemaining, 0); // Return 0 if the cooldown has expired } return 0; } /** * Get player's current enchanted golden apple cooldown * * @param playerUUID The UUID of the player to check the cooldown for. * @return The remaining cooldown time in seconds, or 0 if there is no cooldown, * or it has expired. */ public long getNappleCooldown(UUID playerUUID) { final LastEaten lastEatenInfo = lastEaten.get(playerUUID); if (lastEatenInfo != null && lastEatenInfo.lastEnchantedEaten != null) { long timeElapsedSinceEaten = Duration.between(lastEatenInfo.lastEnchantedEaten, Instant.now()).getSeconds(); long cooldownRemaining = cooldown.enchanted - timeElapsedSinceEaten; return Math.max(cooldownRemaining, 0); // Return 0 if the cooldown has expired } return 0; } private static class LastEaten { private Instant lastNormalEaten; private Instant lastEnchantedEaten; private Optional getForItem(ItemStack item) { return ENCHANTED_GOLDEN_APPLE.isSimilar(item) ? Optional.ofNullable(lastEnchantedEaten) : Optional.ofNullable(lastNormalEaten); } private Optional getNewestEatTime() { if (lastEnchantedEaten == null) { return Optional.ofNullable(lastNormalEaten); } if (lastNormalEaten == null) { return Optional.of(lastEnchantedEaten); } return Optional.of( lastNormalEaten.compareTo(lastEnchantedEaten) < 0 ? lastEnchantedEaten : lastNormalEaten); } private void setForItem(ItemStack item) { if (ENCHANTED_GOLDEN_APPLE.isSimilar(item)) { lastEnchantedEaten = Instant.now(); } else { lastNormalEaten = Instant.now(); } } } private static class Cooldown { private final long normal; private final long enchanted; private final boolean sharedCooldown; private Cooldown(long normal, long enchanted, boolean sharedCooldown) { this.normal = normal; this.enchanted = enchanted; this.sharedCooldown = sharedCooldown; } private long getCooldownForItem(ItemStack item) { return ENCHANTED_GOLDEN_APPLE.isSimilar(item) ? enchanted : normal; } private boolean isOnCooldown(ItemStack item, LastEaten lastEaten) { return (sharedCooldown ? lastEaten.getNewestEatTime() : lastEaten.getForItem(item)) .map(it -> ChronoUnit.SECONDS.between(it, Instant.now())) .map(it -> it < getCooldownForItem(item)) .orElse(false); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldArmourDurability.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import com.cryptomorin.xseries.XEnchantment; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.entity.EntityType; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.event.player.PlayerItemDamageEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.scheduler.BukkitTask; import java.util.*; import java.util.stream.Collectors; public class ModuleOldArmourDurability extends OCMModule { // Armour durability events can fire right after an explosion damage event. We suppress those for one tick so // old-armour-durability doesn't double-apply/over-apply changes during explosion bursts. // // Performance/correctness: // - Use a normal HashMap (WeakHashMap can drop entries unpredictably). // - Avoid scheduling one task per explosion: keep a shared cleanup task that runs only while entries exist. // - Entries expire after 1 tick, which is long enough for the follow-up PlayerItemDamageEvents to fire but // short enough to not interfere with unrelated armour wear later. private final Map explosionDamaged = new HashMap<>(); private BukkitTask explosionCleanupTask; private long explosionTickCounter; public ModuleOldArmourDurability(OCMMain plugin) { super(plugin, "old-armour-durability"); } @EventHandler(priority = EventPriority.LOWEST) public void onItemDamage(PlayerItemDamageEvent e) { final Player player = e.getPlayer(); if (!isEnabled(player)) return; final ItemStack item = e.getItem(); final Material itemType = item.getType(); // Check if it's a piece of armour they're currently wearing if (Arrays.stream(player.getInventory().getArmorContents()) .noneMatch(armourPiece -> armourPiece != null && armourPiece.getType() == itemType && armourPiece.getType() != Material.ELYTRA // ignore elytra as it doesn't provide any protection anyway )) return; final UUID uuid = player.getUniqueId(); if (explosionDamaged.containsKey(uuid)) { final ExplosionDamagedArmour data = explosionDamaged.get(uuid); if (data == null) return; final List armour = data.armour; // ItemStack.equals() checks material, durability and quantity to make sure nothing changed in the meantime // We're checking all the pieces this way just in case they're wearing two helmets or something strange final List matchedPieces = armour.stream() .filter(piece -> piece.equals(item)) .collect(Collectors.toList()); armour.removeAll(matchedPieces); debug("Item matched explosion, ignoring...", player); if (!matchedPieces.isEmpty()) return; } int reduction = module().getInt("reduction"); // 60 + (40 / (level + 1) ) % chance that durability is reduced (for each point of durability) final int damageChance = 60 + (40 / (item.getEnchantmentLevel(XEnchantment.UNBREAKING.getEnchant()) + 1)); final Random random = new Random(); final int randomInt = random.nextInt(100); // between 0 (inclusive) and 100 (exclusive) if (randomInt >= damageChance) reduction = 0; debug("Item damaged: " + itemType + " Damage: " + e.getDamage() + " Changed to: " + reduction, player); e.setDamage(reduction); } @EventHandler(priority = EventPriority.MONITOR) public void onPlayerExplosionDamage(EntityDamageEvent e) { if (e.isCancelled()) return; if (e.getEntityType() != EntityType.PLAYER) return; final EntityDamageEvent.DamageCause cause = e.getCause(); if (cause != EntityDamageEvent.DamageCause.BLOCK_EXPLOSION && cause != EntityDamageEvent.DamageCause.ENTITY_EXPLOSION) return; final Player player = (Player) e.getEntity(); final UUID uuid = player.getUniqueId(); final List armour = Arrays.stream(player.getInventory().getArmorContents()).filter(Objects::nonNull).collect(Collectors.toList()); explosionDamaged.put(uuid, new ExplosionDamagedArmour(armour, explosionTickCounter + 1L)); ensureExplosionCleanupTaskRunning(); debug("Detected explosion!", player); } private void ensureExplosionCleanupTaskRunning() { if (explosionCleanupTask != null) return; explosionTickCounter = 0; explosionCleanupTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { explosionTickCounter++; if (explosionDamaged.isEmpty()) { stopExplosionCleanupTaskIfIdle(); return; } final Iterator> it = explosionDamaged.entrySet().iterator(); while (it.hasNext()) { final ExplosionDamagedArmour data = it.next().getValue(); if (data == null || data.expiresAtTick <= explosionTickCounter) { it.remove(); } } stopExplosionCleanupTaskIfIdle(); }, 1L, 1L); } private void stopExplosionCleanupTaskIfIdle() { if (explosionCleanupTask == null) return; if (!explosionDamaged.isEmpty()) return; explosionCleanupTask.cancel(); explosionCleanupTask = null; } private static final class ExplosionDamagedArmour { private final List armour; private final long expiresAtTick; private ExplosionDamagedArmour(List armour, long expiresAtTick) { this.armour = armour; this.expiresAtTick = expiresAtTick; } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldArmourStrength.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.damage.DefenceUtils; import org.bukkit.entity.Entity; import org.bukkit.entity.LivingEntity; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import java.util.Arrays; import java.util.Map; import java.util.stream.Collectors; /** * Reverts the armour strength changes to 1.8 calculations, including enchantments. * Also recalculates resistance and absorption accordingly. *

* It is based on this revision * of the minecraft wiki. */ public class ModuleOldArmourStrength extends OCMModule { // Defence order is armour defence points -> resistance -> armour enchants -> absorption private boolean randomness; public ModuleOldArmourStrength(OCMMain plugin) { super(plugin, "old-armour-strength"); reload(); } @Override public void reload() { randomness = module().getBoolean("randomness"); } @SuppressWarnings("deprecation") @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) public void onEntityDamage(EntityDamageEvent e) { // 1.8 NMS: Damage = (damage after blocking * (25 - total armour strength)) / 25 if (!(e.getEntity() instanceof LivingEntity)) return; final LivingEntity damagedEntity = (LivingEntity) e.getEntity(); // If there was an attacker, and he does not have this module enabled, return if (e.getCause() == EntityDamageEvent.DamageCause.ENTITY_ATTACK && e instanceof EntityDamageByEntityEvent) { final Entity damager = ((EntityDamageByEntityEvent) e).getDamager(); if(!isEnabled(damager, damagedEntity)) return; } final Map damageModifiers = Arrays.stream(EntityDamageEvent.DamageModifier.values()) .filter(e::isApplicable) .collect(Collectors.toMap(m -> m, e::getDamage)); DefenceUtils.calculateDefenceDamageReduction(damagedEntity, damageModifiers, e.getCause(), randomness); // Set the modifiers back to the event damageModifiers.forEach(e::setDamage); debug("BASE: " + damageModifiers.get(EntityDamageEvent.DamageModifier.BASE)); debug("BLOCKING: " + damageModifiers.get(EntityDamageEvent.DamageModifier.BLOCKING)); debug("ARMOUR: " + damageModifiers.get(EntityDamageEvent.DamageModifier.ARMOR)); debug("RESISTANCE: " + damageModifiers.get(EntityDamageEvent.DamageModifier.RESISTANCE)); debug("ARMOUR ENCHS: " + damageModifiers.get(EntityDamageEvent.DamageModifier.MAGIC)); debug("ABSORPTION: " + damageModifiers.get(EntityDamageEvent.DamageModifier.ABSORPTION)); final double finalDamage = damageModifiers.values().stream().reduce(0.0, Double::sum); debug("Final damage after defence calc: " + finalDamage); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldBrewingStand.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bukkit.Location; import org.bukkit.block.Block; import org.bukkit.block.BlockState; import org.bukkit.block.BrewingStand; import org.bukkit.event.EventHandler; import org.bukkit.event.inventory.InventoryOpenEvent; import org.bukkit.inventory.Inventory; /** * Makes brewing stands not require fuel. */ public class ModuleOldBrewingStand extends OCMModule { public ModuleOldBrewingStand(OCMMain plugin) { super(plugin, "old-brewing-stand"); } @EventHandler public void onInventoryOpen(InventoryOpenEvent e) { // Set max fuel when they open brewing stand // If they run out, they can just close and open it again if (!isEnabled(e.getPlayer())) return; final Inventory inventory = e.getInventory(); final Location location = inventory.getLocation(); if (location == null) return; final Block block = location.getBlock(); final BlockState blockState = block.getState(); if (!(blockState instanceof BrewingStand)) return; final BrewingStand brewingStand = (BrewingStand) blockState; brewingStand.setFuelLevel(20); brewingStand.update(); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldBurnDelay.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bukkit.entity.Entity; import org.bukkit.event.EventHandler; import org.bukkit.event.entity.EntityDamageEvent; /** * Bring back old fire burning delay behaviour */ public class ModuleOldBurnDelay extends OCMModule { private int fireTicks; public ModuleOldBurnDelay(OCMMain plugin) { super(plugin, "old-burn-delay"); reload(); } @Override public void reload() { fireTicks = module().getInt("fire-ticks"); } @EventHandler public void onFireTick(EntityDamageEvent e) { if (e.getCause() == EntityDamageEvent.DamageCause.FIRE) { final Entity entity = e.getEntity(); if(!isEnabled(entity)) return; entity.setFireTicks(fireTicks); debug("Setting fire ticks to " + fireTicks, entity); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldCriticalHits.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent; import kernitus.plugin.OldCombatMechanics.utilities.damage.DamageUtils; import org.bukkit.entity.HumanEntity; import org.bukkit.event.EventHandler; public class ModuleOldCriticalHits extends OCMModule { private boolean allowSprinting; private double multiplier; public ModuleOldCriticalHits(OCMMain plugin) { super(plugin, "old-critical-hits"); reload(); } @Override public void reload() { allowSprinting = module().getBoolean("allowSprinting", true); multiplier = module().getDouble("multiplier", 1.5); } @EventHandler public void onOCMDamage(OCMEntityDamageByEntityEvent e) { if (!isEnabled(e.getDamager(), e.getDamagee())) return; boolean isCritical = e.was1_8Crit(); if (!isCritical && e.getDamager() instanceof HumanEntity) { isCritical = DamageUtils.isCriticalHit1_8((HumanEntity) e.getDamager()); } // In 1.9, a critical hit requires the player not to be sprinting if (isCritical && (allowSprinting || !e.wasSprinting())) e.setCriticalMultiplier(multiplier); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldPotionEffects.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.ConfigUtils; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionDurations; import com.cryptomorin.xseries.XPotion; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionKey; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionEffects; import kernitus.plugin.OldCombatMechanics.utilities.potions.WeaknessCompensation; import org.bukkit.Material; import org.bukkit.World; import org.bukkit.entity.Entity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.HandlerList; import org.bukkit.event.Listener; import org.bukkit.plugin.EventExecutor; import org.bukkit.event.block.Action; import org.bukkit.event.block.BlockDispenseEvent; import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.event.player.PlayerItemConsumeEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import org.bukkit.potion.PotionType; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.lang.reflect.Method; import java.util.Set; import java.util.stream.Collectors; /** * Allows configurable potion effect durations. */ public class ModuleOldPotionEffects extends OCMModule { private static final Set NON_EFFECT_POTION_TYPES = Collections.unmodifiableSet( new HashSet<>(Arrays.asList( "AWKWARD", "MUNDANE", "THICK", "WATER", "UNCRAFTABLE", "HARMING", "STRONG_HARMING", "HEALING", "STRONG_HEALING", "INSTANT_DAMAGE", "INSTANT_HEAL", "INSTANT_HEALTH" ))); private Map durations; private final Set warnedUnknownPotionTypes = new HashSet<>(); private boolean weaknessAmplifierClamped; private boolean potionEffectListenerAttempted; private boolean potionEffectListenerBroken; private Listener potionEffectListener; private Method potionEffectGetEntity; private Method potionEffectGetNewEffect; private Method potionEffectGetOldEffect; private static final String ENTITY_POTION_EFFECT_EVENT = "org.bukkit.event.entity.EntityPotionEffectEvent"; public ModuleOldPotionEffects(OCMMain plugin) { super(plugin, "old-potion-effects"); reload(); } @Override public void reload() { durations = ConfigUtils.loadPotionDurationsList(module()); weaknessAmplifierClamped = detectWeaknessAmplifierClamp(); syncWeaknessCompensation(); updatePotionEffectListener(); } /** * Change the duration using values defined in config for drinking potions */ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void onPlayerDrinksPotion(PlayerItemConsumeEvent event) { final Player player = event.getPlayer(); if (!isEnabled(player)) return; final ItemStack potionItem = event.getItem(); if (potionItem.getType() != Material.POTION) return; adjustPotion(potionItem, false); event.setItem(potionItem); } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPotionDispense(BlockDispenseEvent event) { if (!isEnabled(event.getBlock().getWorld())) return; final ItemStack item = event.getItem(); final Material material = item.getType(); if (material == Material.SPLASH_POTION || material == Material.LINGERING_POTION) adjustPotion(item, true); } // We change the potion on-the-fly just as it's thrown to be able to change the effect @EventHandler(priority = EventPriority.HIGHEST) public void onPotionThrow(PlayerInteractEvent event) { final Player player = event.getPlayer(); if (!isEnabled(player)) return; final Action action = event.getAction(); if (action != Action.RIGHT_CLICK_AIR && action != Action.RIGHT_CLICK_BLOCK) return; final ItemStack item = event.getItem(); if (item == null) return; final Material material = item.getType(); if (material == Material.SPLASH_POTION || material == Material.LINGERING_POTION) adjustPotion(item, true); } @Override public void onModesetChange(Player player) { if (!weaknessAmplifierClamped) { WeaknessCompensation.remove(player); return; } applyWeaknessCompensation(player); } private void updatePotionEffectListener() { if (!weaknessAmplifierClamped) { unregisterPotionEffectListener(); return; } ensurePotionEffectListener(); } private void ensurePotionEffectListener() { if (potionEffectListenerAttempted || potionEffectListenerBroken) return; // EntityPotionEffectEvent exists from 1.13 onwards, and from ~1.20 NMS clamps // Weakness amplifiers to non-negative values which breaks old-damage detection. // Use feature detection (class presence + behaviour checks) rather than version // numbers because some servers backport these APIs/behaviours. potionEffectListenerAttempted = true; final Class eventClass = resolveEntityPotionEffectEvent(); if (eventClass == null) { potionEffectListenerAttempted = false; return; } try { potionEffectGetEntity = eventClass.getMethod("getEntity"); potionEffectGetNewEffect = eventClass.getMethod("getNewEffect"); potionEffectGetOldEffect = eventClass.getMethod("getOldEffect"); } catch (NoSuchMethodException e) { Messenger.warn("[%s] Unable to resolve EntityPotionEffectEvent accessors; weakness compensation is disabled.", getModuleName()); potionEffectListenerBroken = true; return; } potionEffectListener = new Listener() {}; @SuppressWarnings("unchecked") final Class typedEvent = (Class) eventClass; plugin.getServer().getPluginManager().registerEvent( typedEvent, potionEffectListener, EventPriority.MONITOR, new EventExecutor() { @Override public void execute(Listener listener, Event event) { handleEntityPotionEffectEvent(event); } }, plugin, true ); } private void unregisterPotionEffectListener() { if (potionEffectListener == null) return; HandlerList.unregisterAll(potionEffectListener); potionEffectListener = null; potionEffectListenerAttempted = false; potionEffectListenerBroken = false; potionEffectGetEntity = null; potionEffectGetNewEffect = null; potionEffectGetOldEffect = null; } private Class resolveEntityPotionEffectEvent() { try { return Class.forName(ENTITY_POTION_EFFECT_EVENT, false, ModuleOldPotionEffects.class.getClassLoader()); } catch (ClassNotFoundException e) { return null; } } private void handleEntityPotionEffectEvent(Event event) { if (potionEffectListenerBroken || !weaknessAmplifierClamped) return; final Entity entity = extractEntity(event); if (!(entity instanceof LivingEntity)) return; final LivingEntity livingEntity = (LivingEntity) entity; if (!isEnabled(livingEntity)) { WeaknessCompensation.remove(livingEntity); return; } final PotionEffect newEffect = extractPotionEffect(event, potionEffectGetNewEffect); final PotionEffect oldEffect = extractPotionEffect(event, potionEffectGetOldEffect); final PotionEffectType type = newEffect != null ? newEffect.getType() : (oldEffect != null ? oldEffect.getType() : null); final PotionEffectType weakness = XPotion.WEAKNESS.get(); if (type == null || weakness == null || !type.equals(weakness)) return; if (newEffect != null && newEffect.getAmplifier() >= 0) { WeaknessCompensation.apply(livingEntity); } else { WeaknessCompensation.remove(livingEntity); } } private Entity extractEntity(Event event) { if (potionEffectListenerBroken || potionEffectGetEntity == null) return null; try { return (Entity) potionEffectGetEntity.invoke(event); } catch (ReflectiveOperationException e) { potionEffectListenerBroken = true; Messenger.warn("[%s] Failed to read EntityPotionEffectEvent entity; weakness compensation is disabled.", getModuleName()); return null; } } private PotionEffect extractPotionEffect(Event event, Method accessor) { if (potionEffectListenerBroken || accessor == null) return null; try { return (PotionEffect) accessor.invoke(event); } catch (ReflectiveOperationException e) { potionEffectListenerBroken = true; Messenger.warn("[%s] Failed to read EntityPotionEffectEvent effect; weakness compensation is disabled.", getModuleName()); return null; } } /** * Sets custom potion duration and effects * * @param potionItem The potion item with adjusted duration and effects */ private void adjustPotion(ItemStack potionItem, boolean splash) { final PotionMeta potionMeta = (PotionMeta) potionItem.getItemMeta(); if (potionMeta == null) return; PotionType potionType; String potionTypeName; try { potionType = potionMeta.getBasePotionType(); if (potionType == null) return; potionTypeName = potionType.name(); } catch (NoSuchMethodError e) { potionType = potionMeta.getBasePotionData().getType(); potionTypeName = potionType.name(); } final PotionKey potionKey = PotionKey.fromPotionMeta(potionMeta).orElse(null); if (potionKey == null) { if (!NON_EFFECT_POTION_TYPES.contains(potionTypeName) && warnedUnknownPotionTypes.add(potionTypeName)) { Messenger.warn("[%s] Unknown potion type '%s' encountered; old-potion-effects will not adjust it", getModuleName(), potionTypeName); } return; } final Integer duration = getPotionDuration(potionKey, splash); if (duration == null) { debug("Potion type " + potionKey.getDebugName() + " not found in config, leaving as is..."); return; } int amplifier = potionKey.isStrong() ? 1 : 0; if (potionKey.isPotion(XPotion.WEAKNESS)) { // Set level to 0 so that it doesn't prevent the EntityDamageByEntityEvent from being called // due to damage being lower than 0 as some 1.9 weapons deal less damage amplifier = -1; } List potionEffects; try { potionEffects = potionType.getPotionEffects().stream() .map(PotionEffect::getType) .collect(Collectors.toList()); } catch (NoSuchMethodError e) { potionEffects = Collections.singletonList(potionType.getEffectType()); } for (PotionEffectType effectType : potionEffects) { potionMeta.addCustomEffect(new PotionEffect(effectType, duration, amplifier), false); } try { // For >=1.20 potionMeta.setBasePotionType(PotionType.WATER); } catch (NoSuchMethodError e) { potionMeta.setBasePotionData(new PotionData(PotionType.WATER)); } potionItem.setItemMeta(potionMeta); } @EventHandler(ignoreCancelled = true) public void onDamageByEntity(OCMEntityDamageByEntityEvent event) { final Entity damager = event.getDamager(); if (!isEnabled(damager, event.getDamagee())) return; if (event.hasWeakness()) { event.setIsWeaknessModifierMultiplier(module().getBoolean("weakness.multiplier")); final double newWeaknessModifier = module().getDouble("weakness.modifier"); event.setWeaknessModifier(newWeaknessModifier); event.setWeaknessLevel(1); debug("Old weakness modifier: " + event.getWeaknessLevel() + " New: " + newWeaknessModifier, damager); } final double strengthModifier = event.getStrengthModifier(); if (strengthModifier > 0) { event.setIsStrengthModifierMultiplier(module().getBoolean("strength.multiplier")); event.setIsStrengthModifierAddend(module().getBoolean("strength.addend")); final double newStrengthModifier = module().getDouble("strength.modifier"); event.setStrengthModifier(newStrengthModifier); debug("Old strength modifier: " + strengthModifier + " New: " + newStrengthModifier, damager); } } private Integer getPotionDuration(PotionKey potionKey, boolean splash) { final PotionDurations potionDurations = durations.get(potionKey); if (potionDurations == null) return null; final int duration = splash ? potionDurations.splash() : potionDurations.drinkable(); debug("Potion type: " + potionKey.getDebugName() + " Duration: " + duration + " ticks"); return duration; } private boolean detectWeaknessAmplifierClamp() { try { final PotionEffectType weakness = XPotion.WEAKNESS.get(); if (weakness == null) return false; final ItemStack item = new ItemStack(Material.POTION); final PotionMeta meta = (PotionMeta) item.getItemMeta(); if (meta == null) return false; meta.addCustomEffect(new PotionEffect(weakness, 20, -1), true); item.setItemMeta(meta); final PotionMeta updated = (PotionMeta) item.getItemMeta(); if (updated == null) return false; final PotionEffect effect = updated.getCustomEffects().stream() .filter(potionEffect -> potionEffect.getType().equals(weakness)) .findFirst() .orElse(null); return effect != null && effect.getAmplifier() != -1; } catch (Throwable ignored) { return false; } } private void syncWeaknessCompensation() { if (!weaknessAmplifierClamped) { removeWeaknessCompensation(); return; } for (World world : plugin.getServer().getWorlds()) { for (LivingEntity entity : world.getLivingEntities()) { applyWeaknessCompensation(entity); } } } private void removeWeaknessCompensation() { for (World world : plugin.getServer().getWorlds()) { for (LivingEntity entity : world.getLivingEntities()) { WeaknessCompensation.remove(entity); } } } private void applyWeaknessCompensation(LivingEntity entity) { if (!isEnabled(entity)) { WeaknessCompensation.remove(entity); return; } final PotionEffectType weakness = XPotion.WEAKNESS.get(); if (weakness == null) return; final PotionEffect effect = PotionEffects.getOrNull(entity, weakness); if (effect != null && effect.getAmplifier() >= 0) { WeaknessCompensation.apply(entity); } else { WeaknessCompensation.remove(entity); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleOldToolDamage.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.damage.DamageUtils; import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage; import kernitus.plugin.OldCombatMechanics.utilities.damage.OCMEntityDamageByEntityEvent; import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Material; import org.bukkit.entity.Entity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.inventory.ItemStack; import java.math.BigDecimal; import java.util.Arrays; import java.util.List; import java.util.Locale; import java.util.stream.Collectors; /** * Restores old tool damage. */ public class ModuleOldToolDamage extends OCMModule { private static final String[] WEAPONS = {"sword", "axe", "pickaxe", "spade", "shovel", "hoe"}; private static final Class TRIDENT_CLASS; private static final boolean HAS_TRIDENT; private boolean oldSharpness; private boolean tooltipEnabled; private String tooltipPrefix; private final TooltipListener tooltipListener; static { Class tridentClass = null; boolean hasTrident = false; try { tridentClass = Class.forName("org.bukkit.entity.Trident"); hasTrident = true; } catch (ClassNotFoundException ignored) { // Legacy servers (e.g. 1.9/1.12) do not have tridents. } TRIDENT_CLASS = tridentClass; HAS_TRIDENT = hasTrident; } public ModuleOldToolDamage(OCMMain plugin) { super(plugin, "old-tool-damage"); tooltipListener = new TooltipListener(); Bukkit.getPluginManager().registerEvents(tooltipListener, plugin); reload(); } @Override public void reload() { oldSharpness = module().getBoolean("old-sharpness", true); tooltipEnabled = module().getBoolean("tooltip.enabled", false); tooltipPrefix = module().getString("tooltip.prefix", "OCM Damage:"); if (tooltipPrefix == null || tooltipPrefix.trim().isEmpty()) { tooltipPrefix = "OCM Damage:"; } // Update online players so config changes take effect immediately Bukkit.getOnlinePlayers().forEach(tooltipListener::applyToHeld); } @EventHandler(ignoreCancelled = true) public void onEntityDamaged(OCMEntityDamageByEntityEvent event) { final Entity damager = event.getDamager(); if (event.getCause() == EntityDamageEvent.DamageCause.THORNS) return; if (!isEnabled(damager, event.getDamagee())) return; final ItemStack weapon = event.getWeapon(); final Material weaponMaterial = weapon.getType(); final String weaponName = weaponMaterial.name(); debug("Weapon material: " + weaponMaterial); if (!isWeapon(weaponMaterial)) return; final double newWeaponBaseDamage = WeaponDamages.getDamage(weaponMaterial); if (newWeaponBaseDamage <= 0) { debug("Unknown tool type: " + weaponMaterial, damager); return; } final double oldBaseDamage = event.getBaseDamage(); final Float expectedBaseDamage = NewWeaponDamage.getDamageOrNull(weaponMaterial); if (damager instanceof org.bukkit.entity.HumanEntity) { boolean isMace = weaponName.equals("MACE"); double adjustedBase = newWeaponBaseDamage; if (expectedBaseDamage != null) { final double diff = oldBaseDamage - expectedBaseDamage; // For mace we treat diff as the vanilla fall bonus and preserve it. if (isMace) { adjustedBase += diff; } else { // We check difference as calculation inaccuracies can make it not match if (Math.abs(diff) > 0.0001) { debug("Expected " + expectedBaseDamage + " got " + oldBaseDamage + " ignoring weapon..."); return; } } } else { debug("No baseline damage for " + weaponMaterial + ", applying configured damage.", damager); } event.setBaseDamage(adjustedBase); Messenger.debug("Old tool damage: " + oldBaseDamage + " New: " + adjustedBase); } else if (damager instanceof org.bukkit.entity.LivingEntity) { if (expectedBaseDamage == null) { debug("No baseline damage for " + weaponMaterial + ", ignoring mob weapon.", damager); return; } // Mobs do not have a reliable baseline check like players, so we always apply the delta. // This means custom mob weapons are not detected and will still be shifted, which may // interact poorly with other plugins that modify mob damage in non-vanilla ways. final double delta = newWeaponBaseDamage - expectedBaseDamage; final double newBaseDamage = oldBaseDamage + delta; event.setBaseDamage(newBaseDamage); Messenger.debug("Old tool damage (mob): " + oldBaseDamage + " New: " + newBaseDamage); } // Set sharpness to 1.8 damage value final int sharpnessLevel = event.getSharpnessLevel(); double newSharpnessDamage = oldSharpness ? DamageUtils.getOldSharpnessDamage(sharpnessLevel) : DamageUtils.getNewSharpnessDamage(sharpnessLevel); debug("Old sharpness damage: " + event.getSharpnessDamage() + " New: " + newSharpnessDamage, damager); event.setSharpnessDamage(newSharpnessDamage); // The mob enchantments damage remains the same and is linear, no need to recalculate it } private boolean isWeapon(Material material) { final String name = material.name(); if (name.equals("TRIDENT") || name.equals("MACE")) return true; return Arrays.stream(WEAPONS).anyMatch(type -> isOfType(material, type)); } private boolean isOfType(Material mat, String type) { return mat.toString().endsWith("_" + type.toUpperCase(Locale.ROOT)); } @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) public void onTridentProjectile(org.bukkit.event.entity.EntityDamageByEntityEvent event) { if (!HAS_TRIDENT || !TRIDENT_CLASS.isInstance(event.getDamager())) return; if (!isEnabled(event.getDamager(), event.getEntity())) return; final double configured = WeaponDamages.getDamage("TRIDENT_THROWN"); if (configured <= 0) return; event.setDamage(configured); debug("Applied custom thrown trident damage: " + configured, event.getDamager()); } private boolean shouldApplyTooltip(Player player) { if (!tooltipEnabled) return false; return isEnabled(player); } private String formatDamage(double value) { if (value == (long) value) { return Long.toString((long) value); } return BigDecimal.valueOf(value).stripTrailingZeros().toPlainString(); } private List removeExistingTooltip(List lore) { final String needle = tooltipPrefix; if (needle == null || needle.trim().isEmpty()) { return lore; } return lore.stream() .filter(line -> { final String stripped = ChatColor.stripColor(line); return stripped == null || !stripped.startsWith(needle); }) .collect(Collectors.toList()); } private void applyTooltip(Player player, ItemStack item) { if (item == null || item.getType() == Material.AIR) return; if (!isWeapon(item.getType())) { stripTooltip(item); return; } if (!shouldApplyTooltip(player)) { stripTooltip(item); return; } final double configured = WeaponDamages.getDamage(item.getType()); if (configured <= 0) { stripTooltip(item); return; } final org.bukkit.inventory.meta.ItemMeta meta = item.getItemMeta(); if (meta == null) return; final List base = meta.getLore() == null ? new java.util.ArrayList<>() : removeExistingTooltip(meta.getLore()); base.add(ChatColor.BLUE + tooltipPrefix + " " + formatDamage(configured)); meta.setLore(base); item.setItemMeta(meta); } private void stripTooltip(ItemStack item) { if (item == null || item.getType() == Material.AIR) return; final org.bukkit.inventory.meta.ItemMeta meta = item.getItemMeta(); if (meta == null || meta.getLore() == null) return; final List updated = removeExistingTooltip(meta.getLore()); if (updated.size() == meta.getLore().size()) return; if (updated.isEmpty()) { meta.setLore(null); } else { meta.setLore(updated); } item.setItemMeta(meta); } /** * Always-on listener that keeps the tooltip line in sync with the held item, and strips it when the module is * disabled or the item leaves hand. */ private class TooltipListener implements Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onJoin(org.bukkit.event.player.PlayerJoinEvent event) { applyToHeld(event.getPlayer()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onHotbar(org.bukkit.event.player.PlayerItemHeldEvent event) { cleanHand(event.getPlayer(), event.getPreviousSlot()); applyToHeld(event.getPlayer()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onSwap(org.bukkit.event.player.PlayerSwapHandItemsEvent event) { stripTooltip(event.getMainHandItem()); stripTooltip(event.getOffHandItem()); applyTooltip(event.getPlayer(), event.getOffHandItem()); // new main hand after swap stripTooltip(event.getMainHandItem()); // new offhand should stay clean } void applyToHeld(Player player) { final ItemStack item = player.getInventory().getItemInMainHand(); applyTooltip(player, item); } private void cleanHand(Player player, int slot) { final ItemStack old = player.getInventory().getItem(slot); stripTooltip(old); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModulePlayerKnockback.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.cryptomorin.xseries.XAttribute; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.attribute.AttributeInstance; import com.cryptomorin.xseries.XEnchantment; import org.bukkit.entity.Entity; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.event.player.PlayerVelocityEvent; import org.bukkit.inventory.EntityEquipment; import org.bukkit.inventory.ItemStack; import org.bukkit.scheduler.BukkitTask; import org.bukkit.util.Vector; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.UUID; /** * Reverts knockback formula to 1.8. * Also disables netherite knockback resistance. */ public class ModulePlayerKnockback extends OCMModule { private double knockbackHorizontal; private double knockbackVertical; private double knockbackVerticalLimit; private double knockbackExtraHorizontal; private double knockbackExtraVertical; private boolean netheriteKnockbackResistance; // Knockback override for the next PlayerVelocityEvent. // Performance/correctness: // - Use a normal HashMap (WeakHashMap can drop entries unpredictably). // - Keep entries for at most 1 tick. If PlayerVelocityEvent does not fire, a stale entry must not affect // a later, unrelated velocity event (explosions, plugins, etc.). // - Avoid scheduling one task per hit: we run one shared cleanup task only while there is anything pending. private final Map pendingKnockback = new HashMap<>(); private BukkitTask pendingCleanupTask; private long pendingTickCounter; public ModulePlayerKnockback(OCMMain plugin) { super(plugin, "old-player-knockback"); reload(); } @Override public void reload() { knockbackHorizontal = module().getDouble("knockback-horizontal", 0.4); knockbackVertical = module().getDouble("knockback-vertical", 0.4); knockbackVerticalLimit = module().getDouble("knockback-vertical-limit", 0.4); knockbackExtraHorizontal = module().getDouble("knockback-extra-horizontal", 0.5); knockbackExtraVertical = module().getDouble("knockback-extra-vertical", 0.1); netheriteKnockbackResistance = module().getBoolean("enable-knockback-resistance", false) && Reflector.versionIsNewerOrEqualTo(1, 16, 0); } @EventHandler public void onPlayerQuit(PlayerQuitEvent e) { pendingKnockback.remove(e.getPlayer().getUniqueId()); stopCleanupTaskIfIdle(); } // Vanilla does its own knockback, so we need to set it again. // priority = lowest because we are ignoring the existing velocity, which could // break other plugins @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) public void onPlayerVelocityEvent(PlayerVelocityEvent event) { final UUID uuid = event.getPlayer().getUniqueId(); final PendingKnockback pending = pendingKnockback.remove(uuid); if (pending == null) return; event.setVelocity(pending.velocity); stopCleanupTaskIfIdle(); } @EventHandler public void onEntityDamage(EntityDamageEvent event) { // Disable netherite kb, the knockback resistance attribute makes the velocity // event not be called final Entity entity = event.getEntity(); if (!(entity instanceof Player) || netheriteKnockbackResistance) return; final Player damagee = (Player) entity; // This depends on the attacker's combat mode if (event.getCause() == EntityDamageEvent.DamageCause.ENTITY_ATTACK && event instanceof EntityDamageByEntityEvent) { final Entity damager = ((EntityDamageByEntityEvent) event).getDamager(); if (!isEnabled(damager)) return; } else { if (!isEnabled(damagee)) return; } final AttributeInstance attribute = damagee.getAttribute(XAttribute.KNOCKBACK_RESISTANCE.get()); attribute.getModifiers().forEach(attribute::removeModifier); } // Monitor priority because we don't modify anything here, but apply on velocity // change event @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onEntityDamageEntity(EntityDamageByEntityEvent event) { final Entity damager = event.getDamager(); if (!(damager instanceof LivingEntity)) return; final LivingEntity attacker = (LivingEntity) damager; final Entity damagee = event.getEntity(); if (!(damagee instanceof Player)) return; final Player victim = (Player) damagee; if (event.getCause() != EntityDamageEvent.DamageCause.ENTITY_ATTACK) return; if (event.getDamage(EntityDamageEvent.DamageModifier.BLOCKING) > 0) return; if (attacker instanceof HumanEntity) { if (!isEnabled(attacker)) return; } else if (!isEnabled(victim)) return; // Figure out base knockback direction Location attackerLocation = attacker.getLocation(); Location victimLocation = victim.getLocation(); double d0 = attackerLocation.getX() - victimLocation.getX(); double d1; for (d1 = attackerLocation.getZ() - victimLocation.getZ(); d0 * d0 + d1 * d1 < 1.0E-4D; d1 = (Math.random() - Math.random()) * 0.01D) { d0 = (Math.random() - Math.random()) * 0.01D; } final double magnitude = Math.sqrt(d0 * d0 + d1 * d1); // Get player knockback before any friction is applied final Vector playerVelocity = victim.getVelocity(); // Apply friction, then add base knockback playerVelocity.setX((playerVelocity.getX() / 2) - (d0 / magnitude * knockbackHorizontal)); playerVelocity.setY((playerVelocity.getY() / 2) + knockbackVertical); playerVelocity.setZ((playerVelocity.getZ() / 2) - (d1 / magnitude * knockbackHorizontal)); // Calculate bonus knockback for sprinting or knockback enchantment levels final EntityEquipment equipment = attacker.getEquipment(); if (equipment != null) { final ItemStack heldItem = equipment.getItemInMainHand().getType() == Material.AIR ? equipment.getItemInOffHand() : equipment.getItemInMainHand(); int bonusKnockback; if (XEnchantment.KNOCKBACK.getEnchant() == null) { bonusKnockback = 0; } else { bonusKnockback = heldItem.getEnchantmentLevel(XEnchantment.KNOCKBACK.getEnchant()); } if (attacker instanceof Player && ((Player) attacker).isSprinting()) { bonusKnockback++; } if (playerVelocity.getY() > knockbackVerticalLimit) playerVelocity.setY(knockbackVerticalLimit); if (bonusKnockback > 0) { // Apply bonus knockback playerVelocity.add(new Vector((-Math.sin(attacker.getLocation().getYaw() * 3.1415927F / 180.0F) * (float) bonusKnockback * knockbackExtraHorizontal), knockbackExtraVertical, Math.cos(attacker.getLocation().getYaw() * 3.1415927F / 180.0F) * (float) bonusKnockback * knockbackExtraHorizontal)); } } if (netheriteKnockbackResistance) { // Allow netherite to affect the horizontal knockback. Each piece of armour // yields 10% resistance final double resistance = 1 - victim.getAttribute(XAttribute.KNOCKBACK_RESISTANCE.get()).getValue(); playerVelocity.multiply(new Vector(resistance, 1, resistance)); } final UUID victimId = victim.getUniqueId(); // Knockback is sent immediately in 1.8+, there is no reason to send packets // manually pendingKnockback.put(victimId, new PendingKnockback(playerVelocity, pendingTickCounter + 1)); ensureCleanupTaskRunning(); } private void ensureCleanupTaskRunning() { if (pendingCleanupTask != null) return; pendingTickCounter = 0; // Delay by 1 tick so we never expire entries in the same tick they were created. pendingCleanupTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { pendingTickCounter++; if (pendingKnockback.isEmpty()) { stopCleanupTaskIfIdle(); return; } final Iterator> it = pendingKnockback.entrySet().iterator(); while (it.hasNext()) { final PendingKnockback pending = it.next().getValue(); if (pending == null || pending.expiresAtTick <= pendingTickCounter) { it.remove(); } } stopCleanupTaskIfIdle(); }, 1L, 1L); } private void stopCleanupTaskIfIdle() { if (pendingCleanupTask == null) return; if (!pendingKnockback.isEmpty()) return; pendingCleanupTask.cancel(); pendingCleanupTask = null; } private static final class PendingKnockback { private final Vector velocity; private final long expiresAtTick; private PendingKnockback(Vector velocity, long expiresAtTick) { // Defensive clone: callers may re-use/mutate the Vector instance. this.velocity = velocity == null ? new Vector() : velocity.clone(); this.expiresAtTick = expiresAtTick; } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModulePlayerRegen.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.cryptomorin.xseries.XAttribute; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.MathsHelper; import org.bukkit.Bukkit; import org.bukkit.attribute.Attribute; import org.bukkit.entity.EntityType; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityRegainHealthEvent; import org.bukkit.event.player.PlayerQuitEvent; import org.bukkit.scheduler.BukkitTask; import java.util.HashMap; import java.util.Map; import java.util.UUID; /** * Establishes custom health regeneration rules. * Default values based on 1.8 from * wiki */ public class ModulePlayerRegen extends OCMModule { // Vanilla 1.8 natural regen is driven by ticks (foodTickTimer reaches 80 ticks), not wall-clock time. // We therefore measure "interval" in ticks so behaviour stays consistent with TPS drops, rather than // speeding up/slowing down based on real time. // // Performance/correctness: // - Use a normal HashMap (WeakHashMap can drop entries unpredictably). // - Keep a single shared tick counter task that runs only while we are tracking at least one player, rather // than any per-player repeating tasks. private final Map lastHealTick = new HashMap<>(); private BukkitTask tickTask; private long tickCounter; private long intervalTicks; private int healAmount; private float exhaustionToApply; public ModulePlayerRegen(OCMMain plugin) { super(plugin, "old-player-regen"); reload(); } @Override public void reload() { final long intervalMillis = module().getLong("interval"); // Config is in milliseconds for user friendliness, but internal logic is tick based. intervalTicks = Math.max(1L, Math.round(intervalMillis / 50.0)); healAmount = module().getInt("amount"); exhaustionToApply = (float) module().getDouble("exhaustion"); if (tickTask != null && lastHealTick.isEmpty()) { tickTask.cancel(); tickTask = null; } } @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onRegen(EntityRegainHealthEvent e) { if (e.getEntityType() != EntityType.PLAYER || e.getRegainReason() != EntityRegainHealthEvent.RegainReason.SATIATED) return; final Player p = (Player) e.getEntity(); if (!isEnabled(p)) return; final UUID playerId = p.getUniqueId(); // We cancel the regen, but saturation and exhaustion need to be adjusted // separately // Exhaustion is modified in the next tick, and saturation in the tick following // that (if exhaustion > 4) e.setCancelled(true); // Get exhaustion & saturation values before healing modifies them final float previousExhaustion = p.getExhaustion(); final float previousSaturation = p.getSaturation(); ensureTickTaskRunning(); // Check that it has been at least x ticks since last heal final long currentTick = tickCounter; final Long lastTick = lastHealTick.get(playerId); debug("Exh: " + previousExhaustion + " Sat: " + previousSaturation + " Ticks since: " + (lastTick == null ? "?" : (currentTick - lastTick)), p); // If we're skipping this heal, we must fix the exhaustion in the following tick if (lastTick != null && currentTick - lastTick < intervalTicks) { Bukkit.getScheduler().runTaskLater(plugin, () -> p.setExhaustion(previousExhaustion), 1L); return; } final double maxHealth = p.getAttribute(XAttribute.MAX_HEALTH.get()).getValue(); final double playerHealth = p.getHealth(); if (playerHealth < maxHealth) { p.setHealth(MathsHelper.clamp(playerHealth + healAmount, 0.0, maxHealth)); lastHealTick.put(playerId, currentTick); } // Calculate new exhaustion value, must be between 0 and 4. If above, it will // reduce the saturation in the following tick. Bukkit.getScheduler().runTaskLater(plugin, () -> { // We do this in the next tick because bukkit doesn't stop the exhaustion change // when cancelling the event p.setExhaustion(previousExhaustion + exhaustionToApply); debug("Exh before: " + previousExhaustion + " Now: " + p.getExhaustion() + " Sat now: " + previousSaturation, p); }, 1L); } @EventHandler public void onPlayerQuit(PlayerQuitEvent e) { lastHealTick.remove(e.getPlayer().getUniqueId()); stopTickTaskIfIdle(); } private void ensureTickTaskRunning() { if (tickTask != null) return; tickCounter = 0; tickTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { tickCounter++; if (lastHealTick.isEmpty()) { stopTickTaskIfIdle(); } }, 1L, 1L); } private void stopTickTaskIfIdle() { if (tickTask == null) return; if (!lastHealTick.isEmpty()) return; tickTask.cancel(); tickTask = null; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleProjectileKnockback.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bukkit.entity.EntityType; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import java.util.Locale; /** * Adds knockback to eggs, snowballs and ender pearls. */ public class ModuleProjectileKnockback extends OCMModule { public ModuleProjectileKnockback(OCMMain plugin) { super(plugin, "projectile-knockback"); } @EventHandler(priority = EventPriority.NORMAL) public void onEntityHit(EntityDamageByEntityEvent e) { if (!isEnabled(e.getDamager(), e.getEntity())) return; final EntityType type = e.getDamager().getType(); switch (type) { case SNOWBALL: case EGG: case ENDER_PEARL: if (e.getDamage() == 0.0) { // So we don't override enderpearl fall damage e.setDamage(module().getDouble("damage." + type.toString().toLowerCase(Locale.ROOT))); if (e.isApplicable(EntityDamageEvent.DamageModifier.ABSORPTION)) e.setDamage(EntityDamageEvent.DamageModifier.ABSORPTION, 0); } } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleShieldDamageReduction.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.module.ModuleSwordBlocking; import org.bukkit.Bukkit; import org.bukkit.entity.Entity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent.DamageCause; import org.bukkit.event.entity.EntityDamageEvent.DamageModifier; import org.bukkit.event.player.PlayerItemDamageEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.scheduler.BukkitTask; import java.util.*; import java.util.stream.Collectors; /** * Allows customising the shield damage reduction percentages. */ public class ModuleShieldDamageReduction extends OCMModule { private int genericDamageReductionAmount, genericDamageReductionPercentage, projectileDamageReductionAmount, projectileDamageReductionPercentage; // When a hit is fully blocked (0 final damage), vanilla can still damage armour durability. // We cancel that armour durability for one tick only (just long enough for PlayerItemDamageEvent to fire). // // Performance/correctness: // - Use a normal HashMap (WeakHashMap can drop entries unpredictably). // - Avoid scheduling one task per fully-blocked hit: keep a shared cleanup task that runs only while entries exist. private final Map fullyBlocked = new HashMap<>(); private BukkitTask fullyBlockedCleanupTask; private long fullyBlockedTickCounter; public ModuleShieldDamageReduction(OCMMain plugin) { super(plugin, "shield-damage-reduction"); reload(); } @Override public void reload() { genericDamageReductionAmount = module().getInt("generalDamageReductionAmount", 1); genericDamageReductionPercentage = module().getInt("generalDamageReductionPercentage", 50); projectileDamageReductionAmount = module().getInt("projectileDamageReductionAmount", 1); projectileDamageReductionPercentage = module().getInt("projectileDamageReductionPercentage", 50); } @EventHandler(priority = EventPriority.LOWEST) public void onItemDamage(PlayerItemDamageEvent e) { final Player player = e.getPlayer(); if (!isEnabled(player)) return; final UUID uuid = player.getUniqueId(); final ItemStack item = e.getItem(); if (fullyBlocked.containsKey(uuid)) { final FullyBlockedArmour data = fullyBlocked.get(uuid); if (data == null) return; final List armour = data.armour; // ItemStack.equals() checks material, durability and quantity to make sure nothing changed in the meantime // We're checking all the pieces this way just in case they're wearing two helmets or something strange final List matchedPieces = armour.stream().filter(piece -> piece.equals(item)).collect(Collectors.toList()); armour.removeAll(matchedPieces); debug("Ignoring armour durability damage due to full block", player); if (!matchedPieces.isEmpty()) { e.setCancelled(true); } } } @EventHandler(priority = EventPriority.LOWEST) public void onHit(EntityDamageByEntityEvent e) { final Entity entity = e.getEntity(); if (!(entity instanceof Player)) return; final Player player = (Player) entity; if (!isEnabled(e.getDamager(), player)) return; // Paper sword blocking sets the BLOCKING modifier to emulate 1.8 sword blocking. This module is for // shield blocking only; do not double-apply a second reduction when the player is blocking with a sword. final ModuleSwordBlocking swordBlocking = ModuleSwordBlocking.getInstance(); if (swordBlocking != null && swordBlocking.isPaperSwordBlocking(player)) return; // Blocking is calculated after base and hard hat, and before armour etc. final double baseDamage = e.getDamage(DamageModifier.BASE) + e.getDamage(DamageModifier.HARD_HAT); if (!shieldBlockedDamage(baseDamage, e.getDamage(DamageModifier.BLOCKING))) return; final double damageReduction = getDamageReduction(baseDamage, e.getCause()); e.setDamage(DamageModifier.BLOCKING, -damageReduction); final double currentDamage = baseDamage - damageReduction; debug("Blocking: " + baseDamage + " - " + damageReduction + " = " + currentDamage, player); debug("Blocking: " + baseDamage + " - " + damageReduction + " = " + currentDamage); final UUID uuid = player.getUniqueId(); if (currentDamage <= 0) { // Make sure armour is not damaged if fully blocked final List armour = Arrays.stream(player.getInventory().getArmorContents()).filter(Objects::nonNull).collect(Collectors.toList()); fullyBlocked.put(uuid, new FullyBlockedArmour(armour, fullyBlockedTickCounter + 1L)); ensureFullyBlockedCleanupTaskRunning(); } } private void ensureFullyBlockedCleanupTaskRunning() { if (fullyBlockedCleanupTask != null) return; fullyBlockedTickCounter = 0; fullyBlockedCleanupTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { fullyBlockedTickCounter++; if (fullyBlocked.isEmpty()) { stopFullyBlockedCleanupTaskIfIdle(); return; } final Iterator> it = fullyBlocked.entrySet().iterator(); while (it.hasNext()) { final FullyBlockedArmour data = it.next().getValue(); if (data == null || data.expiresAtTick <= fullyBlockedTickCounter) { it.remove(); } } stopFullyBlockedCleanupTaskIfIdle(); }, 1L, 1L); } private void stopFullyBlockedCleanupTaskIfIdle() { if (fullyBlockedCleanupTask == null) return; if (!fullyBlocked.isEmpty()) return; fullyBlockedCleanupTask.cancel(); fullyBlockedCleanupTask = null; } private static final class FullyBlockedArmour { private final List armour; private final long expiresAtTick; private FullyBlockedArmour(List armour, long expiresAtTick) { this.armour = armour; this.expiresAtTick = expiresAtTick; } } private double getDamageReduction(double damage, DamageCause damageCause) { // 1.8 NMS code, where f is damage done, to calculate new damage. // f = (1.0F + f) * 0.5F; // We subtract, to calculate damage reduction instead of new damage double reduction = damage - (damageCause == DamageCause.PROJECTILE ? projectileDamageReductionAmount : genericDamageReductionAmount); // Reduce to percentage reduction *= (damageCause == DamageCause.PROJECTILE ? projectileDamageReductionPercentage : genericDamageReductionPercentage) / 100.0; // Don't reduce by more than the actual damage done // As far as I can tell this is not checked in 1.8NMS, and if the damage was low enough // blocking would lead to higher damage. However, this is hardly the desired result. if (reduction < 0) reduction = 0; return reduction; } private boolean shieldBlockedDamage(double attackDamage, double blockingReduction) { // Only reduce damage if they were hit head on, i.e. the shield blocked some of the damage // This also takes into account damages that are not blocked by shields return attackDamage > 0 && blockingReduction < 0; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleSwordBlocking.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; import org.bukkit.entity.Item; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.block.Action; import org.bukkit.event.block.BlockCanBuildEvent; import org.bukkit.event.entity.PlayerDeathEvent; import org.bukkit.event.inventory.ClickType; import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryDragEvent; import org.bukkit.event.inventory.InventoryType; import org.bukkit.event.player.*; import org.bukkit.inventory.EquipmentSlot; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.PlayerInventory; import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.scheduler.BukkitTask; import java.lang.reflect.Method; import java.util.*; public class ModuleSwordBlocking extends OCMModule { // Not using WeakHashMaps here, for extra reliability private final Map storedItems = new HashMap<>(); private final Map legacyStates = new HashMap<>(); private BukkitTask legacyTask; private long tickCounter; private int restoreDelay; private boolean paperSupported; private Object paperAdapter; private java.lang.reflect.Method paperApply; private java.lang.reflect.Method paperClear; private java.lang.reflect.Method paperHasConsumable; private java.lang.reflect.Method paperIsBlockingSword; private Method startUsingItemMethod; private boolean startUsingItemMethodResolved; private Method craftPlayerGetHandleMethod; private final Map, Method> nmsStartUsingItemCache = new HashMap<>(); private Object minClientVersion; private Method packetEventsGetAPI; private Method packetEventsGetPlayerManager; private Method packetEventsGetUser; private Method packetEventsGetClientVersion; private Method packetEventsUserGetClientVersion; private Method packetEventsIsOlderThan; private Object legacyShieldMarkerKey; private Object legacyShieldMarkerByteType; private Method itemMetaGetPersistentDataContainer; private Method persistentDataContainerSet; private Method persistentDataContainerHas; private static final long ENTITY_INTERACTION_DEDUPE_WINDOW_NANOS = 75_000_000L; private static final long ENTITY_INTERACTION_PRUNE_INTERVAL_NANOS = 250_000_000L; private static final int ENTITY_INTERACTION_FORCE_PRUNE_SIZE = 128; private final Map handledEntityInteractions = new HashMap<>(); private long nextEntityInteractionPruneAtNanos; private static ModuleSwordBlocking INSTANCE; // Only used <1.13, where BlockCanBuildEvent.getPlayer() is not available private Map lastInteractedBlocks; public ModuleSwordBlocking(OCMMain plugin) { super(plugin, "sword-blocking"); INSTANCE = this; if (!Reflector.versionIsNewerOrEqualTo(1, 13, 0)) { lastInteractedBlocks = new WeakHashMap<>(); } initialisePaperAdapter(); initialisePacketEventsClientVersion(); initialiseLegacyShieldMarker(); Bukkit.getPluginManager().registerEvents(new ConsumableLifecycleHandler(), plugin); } @Override public void reload() { restoreDelay = module().getInt("restoreDelay", 40); handledEntityInteractions.clear(); nextEntityInteractionPruneAtNanos = 0L; if (!paperSupported || paperAdapter == null) return; if (isEnabled() && isPaperAnimationEnabled()) return; final Runnable cleanup = () -> { for (Player player : Bukkit.getOnlinePlayers()) { onModesetChange(player); } }; if (Bukkit.isPrimaryThread()) { cleanup.run(); } else { Bukkit.getScheduler().runTask(plugin, cleanup); } } @Override public void onModesetChange(Player player) { if (player == null) return; if (!isEnabled(player)) { restore(player, true); } // Paper component path: when sword-blocking becomes disabled for a player, strip the consumable component // from their items so swords do not remain tainted after mode/world changes. sweepConsumableState(player, true); } private void initialisePaperAdapter() { try { // Paper-only optimisation: use Paper's item data components to give swords a BLOCK use animation // (and the BLOCKING component where available). We keep this behind reflection so the plugin can // still compile against Spigot, and we cache the reflective handles once during initialisation to // keep the hot path allocation-free. final Class adapterClass = Class.forName("kernitus.plugin.OldCombatMechanics.paper.PaperSwordBlocking"); paperAdapter = adapterClass.getConstructor().newInstance(); paperApply = adapterClass.getMethod("applyComponents", ItemStack.class); paperClear = adapterClass.getMethod("clearComponents", ItemStack.class); paperHasConsumable = adapterClass.getMethod("hasConsumableComponent", ItemStack.class); paperIsBlockingSword = adapterClass.getMethod("isBlockingSword", Player.class); paperSupported = true; if (isPaperDataComponentApiPresent()) { plugin.getLogger().info("Paper sword blocking components enabled (no offhand shield swap)."); } } catch (Throwable t) { paperSupported = false; paperAdapter = null; paperApply = null; paperClear = null; paperHasConsumable = null; paperIsBlockingSword = null; // Feature-gated warning: only warn when the Paper data component API is present, otherwise this is a // normal Spigot/non-Paper environment where the Paper path is not expected to work. if (isPaperDataComponentApiPresent()) { final Throwable root = (t instanceof java.lang.reflect.InvocationTargetException && ((java.lang.reflect.InvocationTargetException) t).getTargetException() != null) ? ((java.lang.reflect.InvocationTargetException) t).getTargetException() : t; plugin.getLogger().warning("Paper sword blocking components unavailable; falling back to legacy offhand shield swap. (" + root.getClass().getSimpleName() + (root.getMessage() == null ? "" : (": " + root.getMessage())) + ")"); } } } private void initialisePacketEventsClientVersion() { try { final ClassLoader loader = plugin.getClass().getClassLoader(); final Class packetEventsClass = Class.forName("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.PacketEvents", true, loader); final Class packetEventsApiClass = Class.forName("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.PacketEventsAPI", true, loader); final Class playerManagerClass = Class.forName("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.manager.player.PlayerManager", true, loader); final Class clientVersionClass = Class.forName("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.player.ClientVersion", true, loader); final Class userClass = Class.forName("kernitus.plugin.OldCombatMechanics.lib.packetevents.api.protocol.player.User", true, loader); packetEventsGetAPI = packetEventsClass.getMethod("getAPI"); packetEventsGetPlayerManager = packetEventsApiClass.getMethod("getPlayerManager"); packetEventsGetUser = playerManagerClass.getMethod("getUser", Object.class); packetEventsGetClientVersion = playerManagerClass.getMethod("getClientVersion", Object.class); packetEventsUserGetClientVersion = userClass.getMethod("getClientVersion"); packetEventsIsOlderThan = clientVersionClass.getMethod("isOlderThan", clientVersionClass); minClientVersion = Enum.valueOf((Class) clientVersionClass, "V_1_20_5"); } catch (Throwable ignored) { minClientVersion = null; packetEventsGetAPI = null; packetEventsGetPlayerManager = null; packetEventsGetUser = null; packetEventsGetClientVersion = null; packetEventsUserGetClientVersion = null; packetEventsIsOlderThan = null; } } private void initialiseLegacyShieldMarker() { try { final Class namespacedKeyClass = Class.forName("org.bukkit.NamespacedKey"); final Class pluginClass = Class.forName("org.bukkit.plugin.Plugin"); final Class itemMetaClass = Class.forName("org.bukkit.inventory.meta.ItemMeta"); final Class persistentDataContainerClass = Class.forName("org.bukkit.persistence.PersistentDataContainer"); final Class persistentDataTypeClass = Class.forName("org.bukkit.persistence.PersistentDataType"); legacyShieldMarkerKey = namespacedKeyClass .getConstructor(pluginClass, String.class) .newInstance(plugin, "temporary_legacy_shield"); legacyShieldMarkerByteType = persistentDataTypeClass.getField("BYTE").get(null); itemMetaGetPersistentDataContainer = itemMetaClass.getMethod("getPersistentDataContainer"); persistentDataContainerSet = persistentDataContainerClass.getMethod( "set", namespacedKeyClass, persistentDataTypeClass, Object.class ); persistentDataContainerHas = persistentDataContainerClass.getMethod( "has", namespacedKeyClass, persistentDataTypeClass ); } catch (Throwable ignored) { legacyShieldMarkerKey = null; legacyShieldMarkerByteType = null; itemMetaGetPersistentDataContainer = null; persistentDataContainerSet = null; persistentDataContainerHas = null; } } private boolean supportsPaperAnimation(Player player) { if (!paperSupported || paperAdapter == null) return false; if (player == null) return false; if (!isPaperAnimationEnabled()) return false; if (minClientVersion == null) return false; try { if (packetEventsGetAPI == null || packetEventsGetPlayerManager == null || packetEventsGetClientVersion == null || packetEventsIsOlderThan == null) { return false; } final Object api = packetEventsGetAPI.invoke(null); if (api == null) return false; final Object playerManager = packetEventsGetPlayerManager.invoke(api); if (playerManager == null) return false; Object clientVersion = packetEventsGetClientVersion.invoke(playerManager, player); if (clientVersion == null && packetEventsGetUser != null && packetEventsUserGetClientVersion != null) { final Object user = packetEventsGetUser.invoke(playerManager, player); if (user != null) { clientVersion = packetEventsUserGetClientVersion.invoke(user); } } if (clientVersion == null) return true; if (isUnknownClientVersion(clientVersion)) { // During very early login or synthetic test players, PacketEvents may not have a User yet. // Keep animation support in that case to avoid regressing normal modern-client behaviour. if (packetEventsGetUser != null) { final Object user = packetEventsGetUser.invoke(playerManager, player); if (user == null) return true; } return false; } final Object older = packetEventsIsOlderThan.invoke(clientVersion, minClientVersion); return !(older instanceof Boolean && (Boolean) older); } catch (Throwable ignored) { return false; } } private boolean isPaperDataComponentApiPresent() { try { Class.forName("io.papermc.paper.datacomponent.DataComponentTypes"); return true; } catch (Throwable ignored) { return false; } } @EventHandler(priority = EventPriority.HIGHEST) public void onBlockPlace(BlockCanBuildEvent e) { if (e.isBuildable()) return; Player player; // If <1.13 get player who last interacted with block if (lastInteractedBlocks != null) { final Location blockLocation = e.getBlock().getLocation(); final UUID uuid = lastInteractedBlocks.remove(blockLocation); player = Bukkit.getServer().getPlayer(uuid); } else player = e.getPlayer(); if (player == null || !isEnabled(player)) return; doShieldBlock(player); } @EventHandler(priority = EventPriority.HIGHEST) public void onRightClick(PlayerInteractEvent e) { final Action action = e.getAction(); final Player player = e.getPlayer(); if (!isEnabled(player)) return; if (action != Action.RIGHT_CLICK_BLOCK && action != Action.RIGHT_CLICK_AIR) return; // If they clicked on an interactive block, the 2nd event with the offhand won't fire // This is also the case if the main hand item was used, e.g. a bow if (action == Action.RIGHT_CLICK_BLOCK && e.getHand() == EquipmentSlot.HAND) return; if (e.isBlockInHand()) { if (lastInteractedBlocks != null) { final Block clickedBlock = e.getClickedBlock(); if (clickedBlock != null) lastInteractedBlocks.put(clickedBlock.getLocation(), player.getUniqueId()); } return; // Handle failed block place in separate listener } doShieldBlock(player); } @EventHandler(priority = EventPriority.HIGHEST) public void onRightClickEntity(PlayerInteractEntityEvent event) { handleEntityRightClick(event.getPlayer(), event.getRightClicked(), event.getHand()); } @EventHandler(priority = EventPriority.HIGHEST) public void onRightClickEntityAt(PlayerInteractAtEntityEvent event) { handleEntityRightClick(event.getPlayer(), event.getRightClicked(), event.getHand()); } private void handleEntityRightClick(Player player, org.bukkit.entity.Entity clickedEntity, EquipmentSlot hand) { if (player == null || clickedEntity == null) return; if (!isEnabled(player)) return; if (hand != EquipmentSlot.HAND) return; if (!markEntityInteractionHandled(player, clickedEntity, hand)) return; doShieldBlock(player); } private boolean markEntityInteractionHandled(Player player, org.bukkit.entity.Entity clickedEntity, EquipmentSlot hand) { final long now = System.nanoTime(); lazyPruneHandledEntityInteractions(now, false); final EntityInteractionKey key = new EntityInteractionKey(player.getUniqueId(), clickedEntity.getUniqueId(), hand); final Long expiresAt = handledEntityInteractions.get(key); if (expiresAt != null && expiresAt > now) { return false; } handledEntityInteractions.put(key, now + ENTITY_INTERACTION_DEDUPE_WINDOW_NANOS); lazyPruneHandledEntityInteractions(now, handledEntityInteractions.size() >= ENTITY_INTERACTION_FORCE_PRUNE_SIZE); return true; } private void lazyPruneHandledEntityInteractions(long nowNanos, boolean force) { if (!force && nowNanos < nextEntityInteractionPruneAtNanos) return; final Iterator> it = handledEntityInteractions.entrySet().iterator(); while (it.hasNext()) { if (it.next().getValue() <= nowNanos) { it.remove(); } } nextEntityInteractionPruneAtNanos = nowNanos + ENTITY_INTERACTION_PRUNE_INTERVAL_NANOS; } private void doShieldBlock(Player player) { final PlayerInventory inventory = player.getInventory(); final ItemStack mainHandItem = inventory.getItemInMainHand(); final ItemStack offHandItem = inventory.getItemInOffHand(); if (!isHoldingSword(mainHandItem.getType())) return; if (module().getBoolean("use-permission") && !player.hasPermission("oldcombatmechanics.swordblock")) return; if (supportsPaperAnimation(player)) { // Modern Paper path: we can provide a sword blocking animation via components, without swapping an // offhand shield. This avoids the legacy polling/restore tasks and avoids interfering with offhand // gameplay items (totems, food, etc.). // Set first, then re-read and patch the inventory-backed stack (CraftItemStack) so NMS components // are applied to the real server-side item. inventory.setItemInMainHand(mainHandItem); final ItemStack invMain = inventory.getItemInMainHand(); if (applyConsumableComponent(player, invMain)) { inventory.setItemInMainHand(invMain); } startUsingMainHandIfSupported(player); return; } if (stripConsumable(mainHandItem)) { inventory.setItemInMainHand(mainHandItem); } final UUID id = player.getUniqueId(); if (!isPlayerBlocking(player)) { if (hasShield(inventory)) return; debug("Storing " + offHandItem, player); storedItems.put(id, offHandItem); inventory.setItemInOffHand(createTemporaryLegacyShield()); // Force an inventory update to avoid ghost items player.updateInventory(); // Best-effort: ask the server to start using the offhand item so blocking becomes visible immediately // (and works for fake players / synthetic events). If the API is not present, we fall back silently. startUsingItemIfSupported(player, EquipmentSlot.OFF_HAND); startUsingItemNmsIfSupported(player, true); } // Legacy path: per-player state is required because we temporarily equip a shield. We restore the // original offhand item once the player stops blocking or after a configurable delay. scheduleLegacyRestore(player); applyConsumableComponent(player, mainHandItem); } @EventHandler public void onHotBarChange(PlayerItemHeldEvent e) { restore(e.getPlayer(), true); } @EventHandler(priority = EventPriority.HIGHEST) public void onWorldChange(PlayerChangedWorldEvent e) { restore(e.getPlayer(), true); } @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerJoin(PlayerJoinEvent e) { restore(e.getPlayer(), true); stripConsumableState(e.getPlayer(), true); } @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerLogout(PlayerQuitEvent e) { restore(e.getPlayer(), true); } @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerDeath(PlayerDeathEvent e) { final Player p = e.getEntity(); final UUID id = p.getUniqueId(); final boolean hadMarkedTemporaryOffhand = hasTemporaryLegacyShieldMarker(p.getInventory().getItemInOffHand()); final ItemStack storedOffhand = storedItems.remove(id); final LegacySwordBlockState removedLegacyState = legacyStates.remove(id); if (storedOffhand == null && removedLegacyState == null) return; stopLegacyTaskIfIdle(); if (storedOffhand == null) { return; } if (e.getKeepInventory()) { p.getInventory().setItemInOffHand(storedOffhand); return; } final List drops = e.getDrops(); int temporaryShieldDropIndex = -1; for (int i = 0; i < drops.size(); i++) { if (isTemporaryLegacyShieldDrop(drops.get(i))) { temporaryShieldDropIndex = i; break; } } // Synthetic/manual death events may construct shield drops without preserving item metadata. // If we know the player had our marked temporary shield in offhand, allow a single shield rewrite. if (temporaryShieldDropIndex < 0 && hadMarkedTemporaryOffhand && canMarkTemporaryLegacyShield()) { temporaryShieldDropIndex = firstShieldDropIndex(drops); } if (temporaryShieldDropIndex >= 0) { if (storedOffhand.getType() == Material.AIR) { drops.remove(temporaryShieldDropIndex); } else { drops.set(temporaryShieldDropIndex, storedOffhand); } return; } if (storedOffhand.getType() != Material.AIR) { drops.add(storedOffhand); } } private int firstShieldDropIndex(List drops) { for (int i = 0; i < drops.size(); i++) { final ItemStack item = drops.get(i); if (item != null && item.getType() == Material.SHIELD) { return i; } } return -1; } @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerSwapHandItems(PlayerSwapHandItemsEvent e) { final UUID uuid = e.getPlayer().getUniqueId(); if (!areItemsStored(uuid)) return; if (supportsPaperAnimation(e.getPlayer())) { restore(e.getPlayer(), true); return; } e.setCancelled(true); } @EventHandler(priority = EventPriority.HIGHEST) public void onInventoryClick(InventoryClickEvent e) { if (!(e.getWhoClicked() instanceof Player)) { return; } final Player player = (Player) e.getWhoClicked(); if (!areItemsStored(player.getUniqueId())) { return; } if (isSwapOffhandClick(e) || isTemporaryOffhandShieldClick(e)) { e.setCancelled(true); restore(player, true); } } @EventHandler(priority = EventPriority.HIGHEST) public void onItemDrop(PlayerDropItemEvent e) { final Item is = e.getItemDrop(); final Player p = e.getPlayer(); if (areItemsStored(p.getUniqueId()) && is.getItemStack().getType() == Material.SHIELD) { // Do not cancel here: this event can represent unrelated shield drops from inventory/hotbar. // We only need to end legacy temporary-shield state immediately. restore(p, true); } } private boolean isTemporaryOffhandShieldClick(InventoryClickEvent event) { if (event.getClickedInventory() == null) return false; if (event.getClickedInventory().getType() != InventoryType.PLAYER) return false; if (event.getSlot() != 40) return false; final ItemStack current = event.getCurrentItem(); return current != null && current.getType() == Material.SHIELD; } private boolean isSwapOffhandClick(InventoryClickEvent event) { try { return event.getClick() == ClickType.SWAP_OFFHAND; } catch (NoSuchFieldError ignored) { return false; } } private ItemStack createTemporaryLegacyShield() { final ItemStack shield = new ItemStack(Material.SHIELD); markTemporaryLegacyShield(shield); return shield; } private void markTemporaryLegacyShield(ItemStack item) { if (!canMarkTemporaryLegacyShield()) return; if (item == null || item.getType() != Material.SHIELD) return; try { final ItemMeta meta = item.getItemMeta(); if (meta == null) return; final Object persistentDataContainer = itemMetaGetPersistentDataContainer.invoke(meta); if (persistentDataContainer == null) return; persistentDataContainerSet.invoke( persistentDataContainer, legacyShieldMarkerKey, legacyShieldMarkerByteType, Byte.valueOf((byte) 1) ); item.setItemMeta(meta); } catch (Throwable ignored) { } } private boolean canMarkTemporaryLegacyShield() { return legacyShieldMarkerKey != null && legacyShieldMarkerByteType != null && itemMetaGetPersistentDataContainer != null && persistentDataContainerSet != null && persistentDataContainerHas != null; } private boolean isTemporaryLegacyShieldDrop(ItemStack item) { if (item == null || item.getType() != Material.SHIELD) return false; if (!canMarkTemporaryLegacyShield()) { // Safety-first fallback: without marker support we cannot reliably distinguish temporary shields from // legitimate plain shields, so avoid rewriting any shield drops. return false; } return hasTemporaryLegacyShieldMarker(item); } private boolean hasTemporaryLegacyShieldMarker(ItemStack item) { if (!canMarkTemporaryLegacyShield()) return false; try { final ItemMeta meta = item.getItemMeta(); if (meta == null) return false; final Object persistentDataContainer = itemMetaGetPersistentDataContainer.invoke(meta); if (persistentDataContainer == null) return false; final Object marked = persistentDataContainerHas.invoke( persistentDataContainer, legacyShieldMarkerKey, legacyShieldMarkerByteType ); return marked instanceof Boolean && (Boolean) marked; } catch (Throwable ignored) { return false; } } private void restore(Player player) { restore(player, false); } private void restore(Player p, boolean force) { restore(p, force, false); } private void restore(Player p, boolean force, boolean fromLegacyTask) { final UUID id = p.getUniqueId(); if (!areItemsStored(id)) return; // This method only runs when a legacy offhand item has been stored, so restore unconditionally. // Do not gate this by generic Paper support: older clients on Paper still use the legacy shield fallback. // If they are still blocking with the shield, postpone restoring if (!force && isPlayerBlocking(p)) { if (!fromLegacyTask) { scheduleLegacyRestore(p); } else { // When running inside the legacy tick task, do not touch the map structure while iterating. // Just extend the restore deadline. final LegacySwordBlockState state = legacyStates.get(id); if (state != null) { state.restoreAtTick = tickCounter + Math.max(0, restoreDelay); } } return; } p.getInventory().setItemInOffHand(storedItems.remove(id)); if (!fromLegacyTask) { legacyStates.remove(id); stopLegacyTaskIfIdle(); } } private void scheduleLegacyRestore(Player p) { final UUID id = p.getUniqueId(); final LegacySwordBlockState state = legacyStates.computeIfAbsent(id, ignored -> new LegacySwordBlockState()); state.restoreAtTick = tickCounter + Math.max(0, restoreDelay); state.nextBlockingCheckTick = tickCounter + 10L; ensureLegacyTaskRunning(); } private boolean areItemsStored(UUID uuid) { return storedItems.containsKey(uuid); } /** * Checks whether player is blocking or they have just begun to and shield is not fully up yet. */ private boolean isPlayerBlocking(Player player) { if (!hasShield(player.getInventory())) return false; return player.isBlocking() || (Reflector.versionIsNewerOrEqualTo(1, 11, 0) && player.isHandRaised()); } private boolean hasShield(PlayerInventory inventory) { return inventory.getItemInOffHand().getType() == Material.SHIELD; } private boolean isHoldingSword(Material mat) { return mat.toString().endsWith("_SWORD"); } public static ModuleSwordBlocking getInstance() { return INSTANCE; } /** * Paper path: compute 1.8-style blocking reduction for sword blocking without offhand shield. * * @param event underlying damage event * @param incomingDamage current damage value before blocking is applied (attack side only) * @return reduction amount to subtract from damage, or 0 if not blocking/unsupported. */ public double applyPaperBlockingReduction(org.bukkit.event.entity.EntityDamageByEntityEvent event, double incomingDamage) { if (!paperSupported || paperAdapter == null) return 0; if (!(event.getEntity() instanceof Player)) return 0; final Player player = (Player) event.getEntity(); if (!isPaperAnimationEnabled()) return 0; if (!isEnabled(event.getDamager(), player)) return 0; if (!isHoldingSword(player.getInventory().getItemInMainHand().getType())) return 0; if (!isPaperSwordBlocking(player)) return 0; final int amount = plugin.getConfig().getInt("shield-damage-reduction.generalDamageReductionAmount", 1); final int percent = plugin.getConfig().getInt("shield-damage-reduction.generalDamageReductionPercentage", 50); double reduction = (incomingDamage - amount) * (percent / 100.0); if (reduction < 0) reduction = 0; if (reduction > incomingDamage) reduction = incomingDamage; return reduction; } public boolean isPaperSwordBlocking(Player player) { if (!paperSupported || paperAdapter == null) return false; if (player == null) return false; if (!isPaperAnimationEnabled()) return false; try { if (paperIsBlockingSword != null) { final Object result = paperIsBlockingSword.invoke(paperAdapter, player); if (result instanceof Boolean) { return (Boolean) result; } } } catch (Throwable ignored) { } // Fallback: may work on some combinations, but is not reliable for consumable-based sword blocking. return player.isBlocking() || (Reflector.versionIsNewerOrEqualTo(1, 11, 0) && player.isHandRaised()); } /* ---------- Paper consumable component (animation-only) ---------- */ private boolean applyConsumableComponent(Player player, ItemStack item) { if (!supportsPaperAnimation(player) || paperApply == null) return false; if (item == null || item.getType() == Material.AIR || !isHoldingSword(item.getType())) return false; if (!isEnabled(player)) return false; if (hasConsumableComponent(item)) return false; try { paperApply.invoke(paperAdapter, item); return true; } catch (Throwable ignored) { return false; } } private void startUsingMainHandIfSupported(Player player) { startUsingItemIfSupported(player, EquipmentSlot.HAND); } private void startUsingItemIfSupported(Player player, EquipmentSlot slot) { // Feature-gated: Paper exposes LivingEntity#startUsingItem(EquipmentSlot). Spigot does not. // Without this, some server/client combinations do not transition into the "hand raised" state, even if the // item has a BLOCK use animation (or a shield is injected on legacy path). if (player == null || slot == null) return; if (!startUsingItemMethodResolved) { startUsingItemMethodResolved = true; try { final Class livingEntityClass = Class.forName("org.bukkit.entity.LivingEntity"); startUsingItemMethod = livingEntityClass.getMethod("startUsingItem", EquipmentSlot.class); } catch (Throwable ignored) { startUsingItemMethod = null; } } final java.lang.reflect.Method m = startUsingItemMethod; if (m == null) return; try { m.invoke(player, slot); } catch (Throwable ignored) { } } private void startUsingItemNmsIfSupported(Player player, boolean offhand) { // Ultra-legacy fallback for environments without LivingEntity#startUsingItem(EquipmentSlot). // We reflect into NMS to call LivingEntity#startUsingItem(InteractionHand/EnumHand). if (player == null) return; try { final Class craftPlayerClass = Class.forName("org.bukkit.craftbukkit.entity.CraftPlayer"); if (!craftPlayerClass.isInstance(player)) return; Method getHandle = craftPlayerGetHandleMethod; if (getHandle == null) { getHandle = Reflector.getMethod(craftPlayerClass, "getHandle"); if (getHandle == null) return; craftPlayerGetHandleMethod = getHandle; } final Object handle = getHandle.invoke(player); if (handle == null) return; final Class handleClass = handle.getClass(); Method startUsing = nmsStartUsingItemCache.get(handleClass); if (startUsing == null) { startUsing = resolveNmsStartUsingItem(handleClass); nmsStartUsingItemCache.put(handleClass, startUsing); } if (startUsing == null) return; final Class handType = startUsing.getParameterTypes()[0]; if (!handType.isEnum()) return; final Object hand = enumConstantByName(handType, offhand ? "OFF_HAND" : "MAIN_HAND"); if (hand == null) return; startUsing.invoke(handle, hand); } catch (Throwable ignored) { } } private java.lang.reflect.Method resolveNmsStartUsingItem(Class handleClass) { // Prefer Mojang-named method where available. final Method direct = Reflector.getMethod(handleClass, "startUsingItem", 1); if (direct != null && direct.getReturnType() == void.class && direct.getParameterTypes()[0].isEnum()) { final Class hand = direct.getParameterTypes()[0]; if (enumHasConstant(hand, "MAIN_HAND") && enumHasConstant(hand, "OFF_HAND")) { return direct; } } // Heuristic fallback: any void method taking an enum hand with MAIN_HAND/OFF_HAND constants. Method best = null; int bestScore = -1; Class current = handleClass; while (current != null && current != Object.class) { for (Method m : current.getDeclaredMethods()) { if (m.getParameterCount() != 1) continue; if (m.getReturnType() != void.class) continue; final Class param = m.getParameterTypes()[0]; if (!param.isEnum()) continue; if (!enumHasConstant(param, "MAIN_HAND") || !enumHasConstant(param, "OFF_HAND")) continue; int score = 0; if (m.getName().equals("startUsingItem")) score += 100; if (m.getName().equals("c")) score += 50; if (m.getName().equals("a")) score += 40; final String owner = m.getDeclaringClass().getSimpleName(); if (owner.contains("Living")) score += 20; if (owner.contains("Entity")) score += 10; if (score > bestScore) { bestScore = score; best = m; } } current = current.getSuperclass(); } if (best != null) { best.setAccessible(true); } return best; } private boolean enumHasConstant(Class enumClass, String name) { return enumConstantByName(enumClass, name) != null; } private Object enumConstantByName(Class enumClass, String name) { try { for (Object constant : enumClass.getEnumConstants()) { if (constant instanceof Enum && ((Enum) constant).name().equals(name)) { return constant; } } } catch (Throwable ignored) { } return null; } private boolean stripConsumable(ItemStack item) { if (!paperSupported || paperAdapter == null || paperClear == null || item == null) return false; if (item.getType() == Material.AIR || !isHoldingSword(item.getType())) return false; if (!hasConsumableComponent(item)) return false; try { paperClear.invoke(paperAdapter, item); return true; } catch (Throwable ignored) { return false; } } private boolean hasConsumableComponent(ItemStack item) { if (!paperSupported || paperAdapter == null || paperHasConsumable == null || item == null) return false; try { final Object result = paperHasConsumable.invoke(paperAdapter, item); return result instanceof Boolean && (Boolean) result; } catch (Throwable ignored) { return false; } } private boolean shouldHandleConsumable(Player player) { return paperSupported && paperAdapter != null && player != null && isEnabled(player) && isPaperAnimationEnabled(); } private boolean isPaperAnimationEnabled() { return module().getBoolean("paper-animation", true); } private void sweepConsumableState(Player player, boolean includeStorage) { if (!paperSupported || paperAdapter == null || player == null) return; final PlayerInventory inv = player.getInventory(); final boolean enabled = isEnabled(player); final boolean supportsAnimation = supportsPaperAnimation(player); // Offhand should never carry the component. final ItemStack off = inv.getItemInOffHand(); if (stripConsumable(off)) { inv.setItemInOffHand(off); } final ItemStack main = inv.getItemInMainHand(); if (supportsAnimation && enabled) { if (applyConsumableComponent(player, main)) { inv.setItemInMainHand(main); } if (!includeStorage) { return; } // Keep only the held slot eligible for the component. final int held = inv.getHeldItemSlot(); final ItemStack[] storage = inv.getStorageContents(); for (int i = 0; i < storage.length; i++) { if (i == held) continue; final ItemStack item = storage[i]; if (stripConsumable(item)) { inv.setItem(i, item); } } return; } if (stripConsumable(main)) { inv.setItemInMainHand(main); } if (!includeStorage) { return; } final ItemStack[] storage = inv.getStorageContents(); for (int i = 0; i < storage.length; i++) { final ItemStack item = storage[i]; if (stripConsumable(item)) { inv.setItem(i, item); } } } private void stripConsumableState(Player player, boolean includeStorage) { if (!paperSupported || paperAdapter == null || player == null) return; final PlayerInventory inv = player.getInventory(); final ItemStack main = inv.getItemInMainHand(); if (stripConsumable(main)) { inv.setItemInMainHand(main); } final ItemStack off = inv.getItemInOffHand(); if (stripConsumable(off)) { inv.setItemInOffHand(off); } if (!includeStorage) { return; } final ItemStack[] storage = inv.getStorageContents(); for (int i = 0; i < storage.length; i++) { final ItemStack item = storage[i]; if (stripConsumable(item)) { inv.setItem(i, item); } } } private boolean isUnknownClientVersion(Object clientVersion) { if (!(clientVersion instanceof Enum)) return false; final String name = ((Enum) clientVersion).name(); return "UNKNOWN".equals(name) || "HIGHER_THAN_SUPPORTED_VERSIONS".equals(name); } private class ConsumableLifecycleHandler implements Listener { @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onHeld(PlayerItemHeldEvent event) { if (!shouldHandleConsumable(event.getPlayer()) || !supportsPaperAnimation(event.getPlayer())) return; final PlayerInventory inv = event.getPlayer().getInventory(); final ItemStack prev = inv.getItem(event.getPreviousSlot()); if (stripConsumable(prev)) { inv.setItem(event.getPreviousSlot(), prev); } final ItemStack next = inv.getItem(event.getNewSlot()); if (applyConsumableComponent(event.getPlayer(), next)) { inv.setItem(event.getNewSlot(), next); } } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onSwap(PlayerSwapHandItemsEvent event) { final Player player = event.getPlayer(); if (!shouldHandleConsumable(player) || !supportsPaperAnimation(player)) return; final int heldSlotAtEvent = player.getInventory().getHeldItemSlot(); final org.bukkit.inventory.InventoryView viewAtEvent = player.getOpenInventory(); final org.bukkit.inventory.Inventory eventTop = viewAtEvent == null ? null : viewAtEvent.getTopInventory(); final org.bukkit.inventory.Inventory eventBottom = viewAtEvent == null ? null : viewAtEvent.getBottomInventory(); // Apply/strip against the actual inventory after the swap has taken place. Bukkit.getScheduler().runTask(plugin, () -> { final PlayerInventory inv = player.getInventory(); final ItemStack main = inv.getItemInMainHand(); final ItemStack off = inv.getItemInOffHand(); final boolean mainStripped = stripConsumable(main); final boolean offStripped = stripConsumable(off); final org.bukkit.inventory.InventoryView currentView = player.getOpenInventory(); final boolean viewMatches = currentView != null && currentView.getTopInventory() == eventTop && currentView.getBottomInventory() == eventBottom; final boolean mainApplied = shouldHandleConsumable(player) && supportsPaperAnimation(player) && inv.getHeldItemSlot() == heldSlotAtEvent && viewMatches && applyConsumableComponent(player, main); if (mainStripped || mainApplied) { inv.setItemInMainHand(main); } if (offStripped) { inv.setItemInOffHand(off); } }); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onDrop(PlayerDropItemEvent event) { if (!shouldHandleConsumable(event.getPlayer()) || !supportsPaperAnimation(event.getPlayer())) return; stripConsumable(event.getItemDrop().getItemStack()); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onDeath(PlayerDeathEvent event) { if (!shouldHandleConsumable(event.getEntity()) || !supportsPaperAnimation(event.getEntity())) return; event.getDrops().forEach(ModuleSwordBlocking.this::stripConsumable); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onQuit(PlayerQuitEvent event) { stripConsumableState(event.getPlayer(), true); } @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void onWorldChange(PlayerChangedWorldEvent event) { stripConsumableState(event.getPlayer(), true); } } private void ensureLegacyTaskRunning() { if (legacyTask != null) return; tickCounter = 0; // Performance: previously, sword blocking could schedule per-player repeating tasks. When many players // block at once this scales poorly (scheduler overhead + allocations). Instead, keep per-player state in // a map and run one shared tick task while there is any active legacy blocking state. legacyTask = Bukkit.getScheduler().runTaskTimer(plugin, () -> { tickCounter++; if (legacyStates.isEmpty()) { stopLegacyTaskIfIdle(); return; } // Iterate over a snapshot to avoid ConcurrentModificationException if legacyStates is mutated by other // events during this tick (quit/world change, additional right-clicks, etc.). final List uuids = new ArrayList<>(legacyStates.keySet()); for (UUID uuid : uuids) { final LegacySwordBlockState state = legacyStates.get(uuid); if (state == null) continue; if (!storedItems.containsKey(uuid)) { continue; } final Player player = Bukkit.getPlayer(uuid); if (player == null) { // Cannot restore cleanly; drop state and stored item reference. storedItems.remove(uuid); legacyStates.remove(uuid); continue; } // Mirror previous behaviour: after 10 ticks, poll every 2 ticks for stop-blocking. if (tickCounter >= state.nextBlockingCheckTick) { if (!isPlayerBlocking(player)) { restore(player, false, true); legacyStates.remove(uuid); continue; } state.nextBlockingCheckTick += 2L; } // Restore-delay timeout: attempt restore; if still blocking, restore() reschedules. if (tickCounter >= state.restoreAtTick) { restore(player, false, true); if (!storedItems.containsKey(uuid)) legacyStates.remove(uuid); } } stopLegacyTaskIfIdle(); }, 1L, 1L); } private void stopLegacyTaskIfIdle() { if (legacyTask == null) return; if (!legacyStates.isEmpty()) return; legacyTask.cancel(); legacyTask = null; } private static final class LegacySwordBlockState { private long restoreAtTick; private long nextBlockingCheckTick; } private static final class EntityInteractionKey { private final UUID playerId; private final UUID entityId; private final EquipmentSlot hand; private EntityInteractionKey(UUID playerId, UUID entityId, EquipmentSlot hand) { this.playerId = playerId; this.entityId = entityId; this.hand = hand; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; final EntityInteractionKey that = (EntityInteractionKey) o; return Objects.equals(playerId, that.playerId) && Objects.equals(entityId, that.entityId) && hand == that.hand; } @Override public int hashCode() { return Objects.hash(playerId, entityId, hand); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleSwordSweep.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import com.cryptomorin.xseries.XEnchantment; import kernitus.plugin.OldCombatMechanics.utilities.damage.NewWeaponDamage; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.Entity; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.inventory.ItemStack; import org.bukkit.scheduler.BukkitTask; import java.util.HashSet; import java.util.Set; import java.util.UUID; /** * A module to disable the sweep attack. */ public class ModuleSwordSweep extends OCMModule { // Legacy (pre-1.11) sweep detection: we observe a normal sword hit, then a 1.0 sweep-damage hit follows // immediately afterwards from the same attacker. Track per-attacker, not by Location (yaw/pitch makes Location unstable). private final Set sweepPrimedAttackers = new HashSet<>(); private EntityDamageEvent.DamageCause sweepDamageCause; private BukkitTask pendingClearTask; public ModuleSwordSweep(OCMMain plugin) { super(plugin, "disable-sword-sweep"); try { // Available from 1.11 onwards sweepDamageCause = EntityDamageEvent.DamageCause.valueOf("ENTITY_SWEEP_ATTACK"); } catch (IllegalArgumentException e) { sweepDamageCause = null; } reload(); } @Override public void reload() { // we didn't set anything up in the first place if (sweepDamageCause != null) return; if (pendingClearTask != null) { pendingClearTask.cancel(); pendingClearTask = null; } sweepPrimedAttackers.clear(); } //Changed from HIGHEST to LOWEST to support DamageIndicator plugin @EventHandler(priority = EventPriority.LOWEST) public void onEntityDamaged(EntityDamageByEntityEvent e) { final Entity damager = e.getDamager(); if (!(damager instanceof Player)) return; if (!isEnabled(damager, e.getEntity())) return; if (sweepDamageCause != null) { if (e.getCause() == sweepDamageCause) { e.setCancelled(true); debug("Sweep cancelled", damager); } // sweep attack detected or not, we do not need to fall back to the guessing implementation return; } final Player attacker = (Player) e.getDamager(); final ItemStack weapon = attacker.getInventory().getItemInMainHand(); if (isHoldingSword(weapon.getType())) onSwordAttack(e, attacker, weapon); } private void onSwordAttack(EntityDamageByEntityEvent e, Player attacker, ItemStack weapon) { //Disable sword sweep int level = 0; final Enchantment sweepingEdge = XEnchantment.SWEEPING_EDGE.getEnchant(); if (sweepingEdge != null) { level = weapon.getEnchantmentLevel(sweepingEdge); } final Float baseDamage = NewWeaponDamage.getDamageOrNull(weapon.getType()); if (baseDamage == null) { debug("Unknown sword in NewWeaponDamage: " + weapon.getType() + " (passing through)", attacker); return; } final float damage = baseDamage * level / (level + 1) + 1; if (e.getDamage() == damage) { // Possibly a sword-sweep attack if (sweepPrimedAttackers.contains(attacker.getUniqueId())) { debug("Cancelling sweep...", attacker); e.setCancelled(true); } } else { sweepPrimedAttackers.add(attacker.getUniqueId()); scheduleClearNextTickIfNeeded(); } } private void scheduleClearNextTickIfNeeded() { if (pendingClearTask != null) return; pendingClearTask = Bukkit.getScheduler().runTaskLater(plugin, () -> { sweepPrimedAttackers.clear(); pendingClearTask = null; }, 1L); } private boolean isHoldingSword(Material mat) { return mat.toString().endsWith("_SWORD"); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/ModuleSwordSweepParticles.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import com.github.retrooper.packetevents.PacketEvents; import com.github.retrooper.packetevents.event.PacketListenerAbstract; import com.github.retrooper.packetevents.event.PacketSendEvent; import com.github.retrooper.packetevents.protocol.packettype.PacketType; import com.github.retrooper.packetevents.protocol.particle.Particle; import com.github.retrooper.packetevents.protocol.particle.type.ParticleTypes; import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerParticle; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.entity.Player; /** * A module to disable the sweep attack. */ public class ModuleSwordSweepParticles extends OCMModule { private final ParticleListener particleListener = new ParticleListener(); public ModuleSwordSweepParticles(OCMMain plugin) { super(plugin, "disable-sword-sweep-particles"); reload(); } @Override public void reload() { if (isEnabled()) PacketEvents.getAPI().getEventManager().registerListener(particleListener); else PacketEvents.getAPI().getEventManager().unregisterListener(particleListener); } /** * Hides sweep particles. */ private class ParticleListener extends PacketListenerAbstract { private boolean disabledDueToError; @Override public void onPacketSend(PacketSendEvent packetEvent) { if (disabledDueToError || packetEvent.isCancelled()) return; try { if (!PacketType.Play.Server.PARTICLE.equals(packetEvent.getPacketType())) return; final Object playerObject = packetEvent.getPlayer(); if (!(playerObject instanceof Player)) return; final Player player = (Player) playerObject; if (!isEnabled(player)) return; WrapperPlayServerParticle wrapper = new WrapperPlayServerParticle(packetEvent); Particle particle = wrapper.getParticle(); if (particle == null || particle.getType() == null) return; if (particle.getType() == ParticleTypes.SWEEP_ATTACK) { packetEvent.setCancelled(true); debug("Cancelled sweep particles", player); } } catch (Exception | ExceptionInInitializerError e) { disabledDueToError = true; Messenger.warn( e, "Error detecting sweep packets. Please report it along with the following exception " + "on github." + "Sweep cancellation should still work, but particles might show up." ); } } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/module/OCMModule.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.module; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.storage.PlayerStorage; import org.bukkit.World; import org.bukkit.command.CommandSender; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.entity.Entity; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.Player; import org.bukkit.event.Listener; import org.jetbrains.annotations.NotNull; import java.util.Arrays; import java.util.Locale; import java.util.Set; /** * A module providing some specific functionality, e.g. restoring fishing rod knockback. */ public abstract class OCMModule implements Listener { protected OCMMain plugin; private final String configName; private final String moduleName; /** * Creates a new module. * * @param plugin the plugin instance * @param configName the name of the module in the config */ protected OCMModule(OCMMain plugin, String configName) { this.plugin = plugin; this.configName = configName; this.moduleName = getClass().getSimpleName(); } /** * Checks whether this module is globally en/disabled. * * @return true if this module is globally enabled */ public boolean isEnabled() { return Config.moduleEnabled(configName, null); } /** * Checks whether the module is present in the default modeset for the specified world * * @param world The world to get the default modeset for * @return Whether the module is enabled for the found modeset in the given world */ public boolean isEnabled(World world) { return Config.moduleEnabled(configName, world); } /** * Whether this module should be enabled for this player given his current modeset */ public boolean isEnabled(@NotNull HumanEntity humanEntity) { if (Config.isModuleDisabled(configName)) { return false; } if (Config.isModuleAlwaysEnabled(configName)) { return true; } final World world = humanEntity.getWorld(); final String modesetName = PlayerStorage.getPlayerData(humanEntity.getUniqueId()).getModesetForWorld(world.getUID()); if (modesetName == null) { debug("No modeset found!", humanEntity); debug("No modeset found for " + humanEntity.getName()); return isEnabled(world); } // Check if the modeset contains this module's name final Set modeset = Config.getModesets().get(modesetName); return modeset != null && modeset.contains(configName); } public boolean isEnabled(@NotNull Entity entity) { if (entity instanceof HumanEntity) return isEnabled((HumanEntity) entity); return isEnabled(entity.getWorld()); } /** * Returns if module should be enabled, giving priority to the attacker, if a human. * If neither entity is a human, checks if module should be enabled in the defender's world. * * @param attacker The entity that is performing the attack * @param defender The entity that is being attacked * @return Whether the module should be enabled for this particular interaction */ public boolean isEnabled(@NotNull Entity attacker, @NotNull Entity defender) { if (attacker instanceof HumanEntity) return isEnabled((HumanEntity) attacker); if (defender instanceof HumanEntity) return isEnabled((HumanEntity) defender); return isEnabled(defender.getWorld()); } /** * Checks whether a given setting for this module is enabled. * * @param name the name of the setting * @return true if the setting with that name is enabled. Returns false if the setting did not exist. */ public boolean isSettingEnabled(String name) { return plugin.getConfig().getBoolean(configName + "." + name, false); } /** * Returns the configuration section for this module. * * @return the configuration section for this module */ public ConfigurationSection module() { return plugin.getConfig().getConfigurationSection(configName); } /** * Called when the plugin is reloaded. Should re-read all relevant config keys and other resources that might have * changed. */ public void reload() { // Intentionally left blank! Meant for individual modules to use. } /** * Called when player changes modeset. Re-apply any more permanent changes * depending on result of isEnabled(player). * * @param player The player that changed modeset */ public void onModesetChange(Player player) { // Intentionally left blank! Meant for individual modules to use. } /** * Outputs a debug message. * * @param text the message text */ protected void debug(String text) { Messenger.debug("[" + moduleName + "] " + text); } /** * Sends a debug message to the given command sender. * * @param text the message text * @param sender the sender to send it to */ protected void debug(String text, CommandSender sender) { if (Config.debugEnabled()) { Messenger.sendNoPrefix(sender, "&8&l[&fDEBUG&8&l][&f" + moduleName + "&8&l]&7 " + text); } } @Override public String toString() { return Arrays.stream(configName.split("-")) .map(word -> Character.toUpperCase(word.charAt(0)) + word.substring(1).toLowerCase(Locale.ROOT)) .reduce((a, b) -> a + " " + b) .orElse(configName); } /** * Get the module's name, as taken from the class name * * @return The module name, e.g. ModuleDisableAttackCooldown */ public String getModuleName() { return moduleName; } public String getConfigName() { return configName; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/paper/PaperSwordBlocking.java ================================================ package kernitus.plugin.OldCombatMechanics.paper; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.Optional; import java.util.function.Predicate; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.PlayerInventory; /** * Paper-only helper: NMS reflection-based to avoid linking Paper API at compile time. * * - Patch the underlying NMS ItemStack (DataComponents.CONSUMABLE) so the item is actually usable and the server * can drive the "active item"/hand-raised state. * * Performance: all reflective lookups are done once in the constructor; hot calls only use cached MethodHandles. * We deliberately swallow failures here: if Paper changes internals, we prefer "legacy fallback" over hard failing. */ public class PaperSwordBlocking { private static final float BLOCK_CONSUME_SECONDS = 1.6f; private final MethodHandle nmsApplyComponents; private final MethodHandle nmsSetComponent; private final MethodHandle nmsRemoveComponent; private final MethodHandle nmsGetComponentsPatch; private final MethodHandle nmsPatchGet; private final Object addConsumablePatch; private final Object removeConsumablePatch; private final Object nmsConsumableType; private final Object nmsConsumableComponent; private final Method paperSetDataValue; private final Method paperSetDataBuilder; private final Method paperUnsetData; private final Method paperHasData; private final Method paperEnsureServerConversions; private final Method paperCopyDataFrom; private final Object paperConsumableType; private final Object paperConsumableValue; private final Object paperBaseConsumable; private final Method paperBaseConsumableToBuilder; private final Method paperConsumableBuilderFactory; private final Class paperUseAnimClass; private final Object paperBlockAnimation; private final Class paperValuedTypeClass; private final Class paperBuilderClass; private static final Predicate COPY_ALL_COMPONENTS = ignored -> true; private volatile Field craftItemStackHandleField; private final MethodHandle craftPlayerGetHandle; private final MethodHandle nmsGetUseItem; private final MethodHandle nmsItemStackIs; private final Object nmsSwordTag; public PaperSwordBlocking() throws Exception { // Build the NMS consumable component: Consumable.builder().consumeSeconds(MAX).animation(BLOCK).build() final Class nmsConsumable = Class.forName("net.minecraft.world.item.component.Consumable"); final Object nmsConsumableBuilder = nmsConsumable.getMethod("builder").invoke(null); final Class nmsUseAnim = Class.forName("net.minecraft.world.item.ItemUseAnimation"); final Object nmsBlockAnim = nmsUseAnim.getField("BLOCK").get(null); final Object nmsConsumableValue = nmsConsumableBuilder.getClass().getMethod("consumeSeconds", float.class) .invoke(nmsConsumableBuilder, Float.MAX_VALUE); final Object nmsConsumableValue2 = nmsConsumableValue.getClass().getMethod("animation", nmsUseAnim) .invoke(nmsConsumableValue, nmsBlockAnim); final Object consumableComponent = nmsConsumableValue2.getClass().getMethod("build").invoke(nmsConsumableValue2); nmsConsumableComponent = consumableComponent; // Build patches once: // DataComponentPatch.builder().set(DataComponents.CONSUMABLE, consumableComponent).build() // DataComponentPatch.builder().remove(DataComponents.CONSUMABLE).build() final Class nmsDataComponents = Class.forName("net.minecraft.core.component.DataComponents"); final Object consumableType = nmsDataComponents.getField("CONSUMABLE").get(null); nmsConsumableType = consumableType; final Class nmsPatch = Class.forName("net.minecraft.core.component.DataComponentPatch"); final Object patchBuilderAdd = nmsPatch.getMethod("builder").invoke(null); final Method setMethod = findPatchSetMethod(patchBuilderAdd.getClass()); setMethod.invoke(patchBuilderAdd, consumableType, consumableComponent); addConsumablePatch = patchBuilderAdd.getClass().getMethod("build").invoke(patchBuilderAdd); final Object patchBuilderRemove = nmsPatch.getMethod("builder").invoke(null); final Method removeMethod = findPatchRemoveMethod(patchBuilderRemove.getClass()); removeMethod.invoke(patchBuilderRemove, consumableType); removeConsumablePatch = patchBuilderRemove.getClass().getMethod("build").invoke(patchBuilderRemove); Method setDataValueHandle = null; Method setDataBuilderHandle = null; Method unsetDataHandle = null; Method hasDataHandle = null; Method ensureServerConversionsHandle = null; Method copyDataFromHandle = null; Object consumableTypePaper = null; Object consumableValuePaper = null; Object baseConsumablePaper = null; Method baseConsumableToBuilder = null; Method consumableBuilderFactory = null; Class useAnimClass = null; Object blockAnimation = null; Class valuedTypeClass = null; Class builderClass = null; try { final Class paperItemStack = Class.forName("org.bukkit.inventory.ItemStack"); final Class paperDataComponentType = Class.forName("io.papermc.paper.datacomponent.DataComponentType"); final Class paperDataComponentTypeValued = Class.forName("io.papermc.paper.datacomponent.DataComponentType$Valued"); final Class paperDataComponentBuilder = Class.forName("io.papermc.paper.datacomponent.DataComponentBuilder"); valuedTypeClass = paperDataComponentTypeValued; builderClass = paperDataComponentBuilder; final Class paperDataComponentTypes = Class.forName("io.papermc.paper.datacomponent.DataComponentTypes"); consumableTypePaper = paperDataComponentTypes.getField("CONSUMABLE").get(null); final Method getData = paperItemStack.getMethod("getData", paperDataComponentTypeValued); final Object bread = new ItemStack(Material.BREAD); baseConsumablePaper = getData.invoke(bread, consumableTypePaper); useAnimClass = Class.forName("io.papermc.paper.datacomponent.item.consumable.ItemUseAnimation"); blockAnimation = useAnimClass.getField("BLOCK").get(null); if (baseConsumablePaper != null) { baseConsumableToBuilder = baseConsumablePaper.getClass().getMethod("toBuilder"); } final Class paperConsumable = Class.forName("io.papermc.paper.datacomponent.item.Consumable"); consumableBuilderFactory = paperConsumable.getMethod("consumable"); Method setDataMethodValue = null; Method setDataMethodBuilder = null; for (Method m : paperItemStack.getMethods()) { if (!m.getName().equals("setData")) continue; if (m.getParameterCount() != 2) continue; if (!paperDataComponentTypeValued.isAssignableFrom(m.getParameterTypes()[0])) continue; if (paperDataComponentBuilder.isAssignableFrom(m.getParameterTypes()[1])) { setDataMethodBuilder = m; continue; } setDataMethodValue = m; } if (setDataMethodValue != null || setDataMethodBuilder != null) { final Method unset = paperItemStack.getMethod("unsetData", paperDataComponentType); final Method has = paperItemStack.getMethod("hasData", paperDataComponentType); final Method ensure = paperItemStack.getMethod("ensureServerConversions"); final Method copyFrom = paperItemStack.getMethod("copyDataFrom", paperItemStack, Predicate.class); if (setDataMethodValue != null) { setDataMethodValue.setAccessible(true); } if (setDataMethodBuilder != null) { setDataMethodBuilder.setAccessible(true); } unset.setAccessible(true); has.setAccessible(true); ensure.setAccessible(true); copyFrom.setAccessible(true); setDataValueHandle = setDataMethodValue; setDataBuilderHandle = setDataMethodBuilder; unsetDataHandle = unset; hasDataHandle = has; ensureServerConversionsHandle = ensure; copyDataFromHandle = copyFrom; } } catch (Throwable ignored) { consumableTypePaper = null; consumableValuePaper = null; baseConsumablePaper = null; baseConsumableToBuilder = null; consumableBuilderFactory = null; useAnimClass = null; blockAnimation = null; } paperSetDataValue = setDataValueHandle; paperSetDataBuilder = setDataBuilderHandle; paperUnsetData = unsetDataHandle; paperHasData = hasDataHandle; paperEnsureServerConversions = ensureServerConversionsHandle; paperCopyDataFrom = copyDataFromHandle; paperConsumableType = consumableTypePaper; paperConsumableValue = consumableValuePaper; paperBaseConsumable = baseConsumablePaper; paperBaseConsumableToBuilder = baseConsumableToBuilder; paperConsumableBuilderFactory = consumableBuilderFactory; paperUseAnimClass = useAnimClass; paperBlockAnimation = blockAnimation; paperValuedTypeClass = valuedTypeClass; paperBuilderClass = builderClass; // NMS ItemStack#applyComponents(DataComponentPatch) final Class nmsItemStack = Class.forName("net.minecraft.world.item.ItemStack"); final Method apply = nmsItemStack.getMethod("applyComponents", nmsPatch); final MethodHandles.Lookup lookup = MethodHandles.publicLookup(); nmsApplyComponents = lookup.unreflect(apply); final Class nmsComponentType = Class.forName("net.minecraft.core.component.DataComponentType"); nmsSetComponent = lookup.unreflect(findItemStackSetMethod(nmsItemStack, nmsComponentType)); nmsRemoveComponent = lookup.unreflect(findItemStackRemoveMethod(nmsItemStack, nmsComponentType)); nmsGetComponentsPatch = lookup.unreflect(nmsItemStack.getMethod("getComponentsPatch")); nmsPatchGet = lookup.unreflect(nmsPatch.getMethod("get", nmsComponentType)); // Detect sword blocking via active item use: // player.getUseItem().is(ItemTags.SWORDS) // (Bukkit's Player#isBlocking and #isHandRaised are shield-biased and do not reliably track the // consumable-based sword use animation across server/client combinations.) final Class craftPlayer = Class.forName("org.bukkit.craftbukkit.entity.CraftPlayer"); craftPlayerGetHandle = lookup.unreflect(craftPlayer.getMethod("getHandle")); final Class nmsPlayer = Class.forName("net.minecraft.world.entity.player.Player"); nmsGetUseItem = lookup.unreflect(nmsPlayer.getMethod("getUseItem")); final Object swordTag = Class.forName("net.minecraft.tags.ItemTags").getField("SWORDS").get(null); nmsSwordTag = swordTag; nmsItemStackIs = lookup.unreflect(findItemStackIsMethod(nmsItemStack, swordTag)); } private Field resolveCraftItemStackHandleField(ItemStack stack) throws NoSuchFieldException { final Field cached = craftItemStackHandleField; if (cached != null) return cached; Class c = stack.getClass(); while (c != null && c != Object.class) { try { final Field f = c.getDeclaredField("handle"); f.setAccessible(true); craftItemStackHandleField = f; return f; } catch (NoSuchFieldException ignored) { c = c.getSuperclass(); } } throw new NoSuchFieldException("No 'handle' field found on " + stack.getClass().getName()); } private Method findPatchSetMethod(Class builderClass) throws NoSuchMethodException { for (Method m : builderClass.getMethods()) { if (!m.getName().equals("set")) continue; if (m.getParameterCount() != 2) continue; return m; } throw new NoSuchMethodException("DataComponentPatch.Builder#set(type, value) not found"); } private Method findPatchRemoveMethod(Class builderClass) throws NoSuchMethodException { for (Method m : builderClass.getMethods()) { if (!m.getName().equals("remove")) continue; if (m.getParameterCount() != 1) continue; return m; } throw new NoSuchMethodException("DataComponentPatch.Builder#remove(type) not found"); } private Method findItemStackIsMethod(Class nmsItemStackClass, Object tagInstance) throws NoSuchMethodException { for (Method m : nmsItemStackClass.getMethods()) { if (!m.getName().equals("is")) continue; if (m.getParameterCount() != 1) continue; if (m.getReturnType() != boolean.class) continue; final Class param = m.getParameterTypes()[0]; // NMS has multiple "is(...)" overloads. We specifically need the tag overload used by // ItemStack#is(ItemTags.SWORDS). Pick an overload whose parameter can accept the tag object. if (tagInstance != null && param.isInstance(tagInstance)) { return m; } if (tagInstance != null && param.isAssignableFrom(tagInstance.getClass())) { return m; } // Heuristic fallback: TagKey / HolderSet based overloads tend to include "TagKey" in their type name. if (param.getName().contains("TagKey")) { return m; } } throw new NoSuchMethodException("ItemStack#is(tag) not found"); } public void applyComponents(ItemStack stack) { applyComponentsInternal(stack, true); } private void applyComponentsInternal(ItemStack stack, boolean allowTestSync) { if (stack == null || stack.getType() == Material.AIR || !isSword(stack.getType())) return; boolean applied = false; if (paperSetDataValue != null && paperConsumableType != null) { final Object value = paperConsumableValue != null ? paperConsumableValue : buildPaperConsumableValue(); if (value != null) { try { applied = setPaperDataValue(stack, value); } catch (Throwable ignored) { applied = false; } } } if (!applied && paperSetDataBuilder != null && paperConsumableType != null) { final Object builder = buildPaperConsumableBuilder(); if (builder != null) { try { applied = setPaperDataBuilder(stack, builder); } catch (Throwable ignored) { applied = false; } } } if (!applied && paperConsumableType != null && paperValuedTypeClass != null) { final Object value = buildPaperConsumableValue(); if (value != null) { applied = setPaperDataValue(stack, value); } } if (!applied && paperConsumableType != null && paperBuilderClass != null) { final Object builder = buildPaperConsumableBuilder(); if (builder != null) { applied = setPaperDataBuilder(stack, builder); } } if (applied) { ensureServerConversions(stack); if (allowTestSync) { syncTestInventories(stack); } return; } try { final Field handleField = resolveCraftItemStackHandleField(stack); final Object nms = handleField.get(stack); if (nms != null) { nmsSetComponent.invoke(nms, nmsConsumableType, nmsConsumableComponent); } ensureServerConversions(stack); if (allowTestSync) { syncTestInventories(stack); } } catch (Throwable ignored) { } } public void clearComponents(ItemStack stack) { if (stack == null) return; boolean cleared = false; if (paperUnsetData != null && paperConsumableType != null) { try { paperUnsetData.invoke(stack, paperConsumableType); cleared = true; } catch (Throwable ignored) { cleared = false; } } if (cleared) { ensureServerConversions(stack); return; } try { final Field handleField = resolveCraftItemStackHandleField(stack); final Object nms = handleField.get(stack); if (nms != null) { nmsRemoveComponent.invoke(nms, nmsConsumableType); } ensureServerConversions(stack); } catch (Throwable ignored) { } } private Method findItemStackSetMethod(Class nmsItemStackClass, Class nmsComponentTypeClass) throws NoSuchMethodException { for (Method m : nmsItemStackClass.getMethods()) { if (!m.getName().equals("set")) continue; if (m.getParameterCount() != 2) continue; if (!m.getParameterTypes()[0].isAssignableFrom(nmsComponentTypeClass)) continue; return m; } throw new NoSuchMethodException("ItemStack#set(component, value) not found"); } private Method findItemStackRemoveMethod(Class nmsItemStackClass, Class nmsComponentTypeClass) throws NoSuchMethodException { for (Method m : nmsItemStackClass.getMethods()) { if (!m.getName().equals("remove")) continue; if (m.getParameterCount() != 1) continue; if (!m.getParameterTypes()[0].isAssignableFrom(nmsComponentTypeClass)) continue; return m; } throw new NoSuchMethodException("ItemStack#remove(component) not found"); } public boolean hasConsumableComponent(ItemStack stack) { if (stack == null || stack.getType() == Material.AIR || !isSword(stack.getType())) return false; if (paperHasData != null && paperConsumableType != null) { try { final Object result = paperHasData.invoke(stack, paperConsumableType); if (result instanceof Boolean) { return (Boolean) result; } } catch (Throwable ignored) { } } try { final Field handleField = resolveCraftItemStackHandleField(stack); final Object nms = handleField.get(stack); if (nms == null) return false; final Object patch = nmsGetComponentsPatch.invoke(nms); if (patch == null) return false; final Object entry = nmsPatchGet.invoke(patch, nmsConsumableType); if (!(entry instanceof Optional)) return false; return ((Optional) entry).isPresent(); } catch (Throwable ignored) { return false; } } private void ensureServerConversions(ItemStack stack) { if (paperEnsureServerConversions == null || paperCopyDataFrom == null || stack == null) return; try { final Object converted = paperEnsureServerConversions.invoke(stack); if (!(converted instanceof ItemStack)) return; if (converted == stack) return; paperCopyDataFrom.invoke(stack, converted, COPY_ALL_COMPONENTS); } catch (Throwable ignored) { } } private boolean setPaperDataValue(ItemStack stack, Object value) { if (stack == null || value == null || paperConsumableType == null) return false; try { Method method = paperSetDataValue; if (method == null && paperValuedTypeClass != null) { method = stack.getClass().getMethod("setData", paperValuedTypeClass, Object.class); } if (method == null) return false; method.invoke(stack, paperConsumableType, value); return true; } catch (Throwable ignored) { return false; } } private boolean setPaperDataBuilder(ItemStack stack, Object builder) { if (stack == null || builder == null || paperConsumableType == null || paperBuilderClass == null) return false; try { Method method = paperSetDataBuilder; if (method == null) { method = stack.getClass().getMethod("setData", paperValuedTypeClass, paperBuilderClass); } if (method == null) return false; method.invoke(stack, paperConsumableType, builder); return true; } catch (Throwable ignored) { return false; } } private Object buildPaperConsumableBuilder() { if (paperConsumableType == null || paperUseAnimClass == null || paperBlockAnimation == null) return null; try { Object builder = null; boolean fromBase = false; if (paperBaseConsumable != null && paperBaseConsumableToBuilder != null) { builder = paperBaseConsumableToBuilder.invoke(paperBaseConsumable); fromBase = true; } if (builder == null && paperConsumableBuilderFactory != null) { builder = paperConsumableBuilderFactory.invoke(null); fromBase = false; } if (builder == null) return null; Object configured = builder; if (!fromBase) { configured = configured.getClass().getMethod("consumeSeconds", float.class).invoke(configured, BLOCK_CONSUME_SECONDS); } final Object withAnim = configured.getClass().getMethod("animation", paperUseAnimClass).invoke(configured, paperBlockAnimation); return withAnim; } catch (Throwable ignored) { return null; } } private Object buildPaperConsumableValue() { final Object builder = buildPaperConsumableBuilder(); if (builder == null) return null; try { return builder.getClass().getMethod("build").invoke(builder); } catch (Throwable ignored) { return null; } } private void syncTestInventories(ItemStack stack) { if (!isTestServer() || stack == null) return; for (Player player : Bukkit.getOnlinePlayers()) { final PlayerInventory inventory = player.getInventory(); final int size = inventory.getSize(); for (int slot = 0; slot < size; slot++) { final ItemStack candidate = inventory.getItem(slot); if (candidate == null) continue; if (!candidate.isSimilar(stack)) continue; applyComponentsInternal(candidate, false); inventory.setItem(slot, candidate); } final ItemStack cursor = player.getItemOnCursor(); if (cursor != null && cursor.isSimilar(stack)) { applyComponentsInternal(cursor, false); player.setItemOnCursor(cursor); } } } private boolean isTestServer() { return Bukkit.getPluginManager().getPlugin("OldCombatMechanicsTest") != null; } public boolean isBlockingSword(Player player) { if (player == null) return false; try { final Object nmsPlayer = craftPlayerGetHandle.invoke(player); if (nmsPlayer == null) return false; final Object useItem = nmsGetUseItem.invoke(nmsPlayer); if (useItem == null) return false; return (boolean) nmsItemStackIs.invoke(useItem, nmsSwordTag); } catch (Throwable ignored) { return false; } } private boolean isSword(Material mat) { return mat != null && mat.name().endsWith("_SWORD"); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/updater/ModuleUpdateChecker.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.updater; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.UpdateChecker; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.player.PlayerJoinEvent; public class ModuleUpdateChecker extends OCMModule { public ModuleUpdateChecker(OCMMain plugin) { super(plugin, "update-checker"); } @EventHandler public void onPlayerLogin(PlayerJoinEvent e) { final Player player = e.getPlayer(); if (player.hasPermission("OldCombatMechanics.notify")) Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, () -> new UpdateChecker(plugin).performUpdate(), 20L); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/updater/SpigetUpdateChecker.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.updater; import com.google.gson.Gson; import com.google.gson.JsonSyntaxException; import com.google.gson.reflect.TypeToken; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import java.io.*; import java.lang.reflect.Type; import java.net.HttpURLConnection; import java.net.URL; import java.nio.channels.Channels; import java.nio.channels.FileChannel; import java.nio.channels.ReadableByteChannel; import java.util.Collections; import java.util.List; /** * Checks Spiget for updates. */ public class SpigetUpdateChecker { private static final String USER_AGENT = "OldCombatMechanics"; private static final String VERSIONS_URL = "https://api.spiget.org/v2/resources/19510/versions?size=15000"; private static final String UPDATES_URL = "https://api.spiget.org/v2/resources/19510/updates?size=15000"; private static final String UPDATE_URL = "https://www.spigotmc.org/resources/oldcombatmechanics.19510/update?update="; private static final String DOWNLOAD_URL = "https://api.spiget.org/v2/resources/19510/download"; private String latestVersion = ""; /** * Returns whether an update is available. * * @return true if an update is available */ public boolean isUpdateAvailable() { try { final List versions = getVersions(VERSIONS_URL); if (versions.isEmpty()) return false; final VersionPojo currentVersion = versions.get(versions.size() - 1); latestVersion = currentVersion.getName(); return VersionChecker.shouldUpdate(latestVersion); } catch (Exception e) { e.printStackTrace(); return false; } } /** * Returns the URL for the update. * * @return URL for the update */ public String getUpdateURL() { try { final List versions = getVersions(UPDATES_URL); if (versions.isEmpty()) return "Error getting update URL"; final VersionPojo currentVersion = versions.get(versions.size() - 1); return UPDATE_URL + currentVersion.getId(); } catch (Exception e) { return "Error getting update URL"; } } /** * Returns the latest found version. Only populated after a call to {@link #isUpdateAvailable()}. * * @return the latest found version */ public String getLatestVersion() { return latestVersion; } /** * Downloads the latest version of the plugin to the specified location. * * @param updateFolderFile The location of the server's plugin update folder * @param fileName The name of the JAR file to be updated * @return Whether the file was downloaded successfully or not */ public boolean downloadLatestVersion(File updateFolderFile, String fileName) { updateFolderFile.mkdirs(); // Create all parent directories if required File downloadFile = new File(updateFolderFile, fileName); try { final HttpURLConnection connection = (HttpURLConnection) new URL(DOWNLOAD_URL).openConnection(); connection.addRequestProperty("User-Agent", USER_AGENT); try (FileOutputStream fileOutputStream = new FileOutputStream(downloadFile); final ReadableByteChannel readableByteChannel = Channels.newChannel(connection.getInputStream()); final FileChannel fileChannel = fileOutputStream.getChannel(); ) { // Use NIO for better performance fileChannel.transferFrom(readableByteChannel, 0, Long.MAX_VALUE); } catch (Exception e) { downloadFile.delete(); // Remove downloaded file is something went wrong throw new RuntimeException(e); // Rethrow exception to catch in outer scope } } catch (IOException e) { Messenger.warn("Tried to download plugin update, but an error occurred"); e.printStackTrace(); return false; } return true; } /** * Returns all versions. * * @param urlString the url to read the json from * @return a list with all found versions */ private List getVersions(String urlString) { try { final InputStreamReader reader = fetchPage(urlString); final Type pojoType = new TypeToken>() { }.getType(); final List parsedVersions = new Gson().fromJson(reader, pojoType); if (parsedVersions == null) { System.err.println("JSON was at EOF when checking for spiget updates!"); return Collections.emptyList(); } return parsedVersions; } catch (JsonSyntaxException | IOException e) { e.printStackTrace(); return Collections.emptyList(); } } private InputStreamReader fetchPage(String urlString) throws IOException { final URL url = new URL(urlString); final HttpURLConnection connection = (HttpURLConnection) url.openConnection(); connection.addRequestProperty("User-Agent", USER_AGENT); connection.setConnectTimeout(10000); // 10 seconds connection.setReadTimeout(10000); // 10 seconds try { int status = connection.getResponseCode(); if (status == HttpURLConnection.HTTP_OK) { InputStream inputStream = connection.getInputStream(); return new InputStreamReader(inputStream); } else { // Log error or handle other status codes appropriately throw new IOException("Server returned non-OK status: " + status); } } catch (IOException e) { // Log exception with as much detail as possible throw e; } } /** * A pojo for a version returned by Spiget. */ private static class VersionPojo { // Created by GSON @SuppressWarnings("unused") private String name; @SuppressWarnings("unused") private String id; /** * The name. Might be null, if this was an update request. * * @return the name of this version */ String getName() { return name; } /** * The id of this version. * * @return the id of this version */ String getId() { return id; } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/updater/VersionChecker.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.updater; import kernitus.plugin.OldCombatMechanics.OCMMain; import java.util.regex.Matcher; import java.util.regex.Pattern; public class VersionChecker { public static boolean shouldUpdate(String remoteVersion) { return isUpdateOut(remoteVersion, OCMMain.getVersion()); } private static boolean isUpdateOut(String remoteVersion, String localVersion) { final int[] testVer = getVersionNumbers(remoteVersion); final int[] baseVer = getVersionNumbers(localVersion); for (int i = 0; i < testVer.length; i++) { if (testVer[i] != baseVer[i]) return testVer[i] > baseVer[i]; } return false; } private static int[] getVersionNumbers(String ver) { // Support both -beta and -SNAPSHOT Matcher m = Pattern .compile("(\\d+)\\.(\\d+)(?:\\.(\\d+))?(?:-(beta|SNAPSHOT)(\\d*))?", Pattern.CASE_INSENSITIVE) .matcher(ver); if (!m.matches()) throw new IllegalArgumentException("Plugin version formatted wrong!"); return new int[] { Integer.parseInt(m.group(1)), // MAJOR Integer.parseInt(m.group(2)), // MINOR m.group(3) == null ? 0 : Integer.parseInt(m.group(3)), // PATCH (default 0) m.group(4) == null ? Integer.MAX_VALUE : // Release version (m.group(5).isEmpty() ? 0 : Integer.parseInt(m.group(5))) // Pre-release number }; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/Config.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; import kernitus.plugin.OldCombatMechanics.ModuleLoader; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import kernitus.plugin.OldCombatMechanics.utilities.damage.EntityDamageByEntityListener; import kernitus.plugin.OldCombatMechanics.utilities.damage.WeaponDamages; import org.bukkit.Bukkit; import org.bukkit.World; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import javax.annotation.Nullable; import java.io.InputStreamReader; import java.util.*; import java.util.logging.Level; import java.util.stream.Collectors; public class Config { private static final String CONFIG_NAME = "config.yml"; private static OCMMain plugin; private static FileConfiguration config; private static final Map> modesets = new HashMap<>(); private static final Map> worlds = new HashMap<>(); private static final Set alwaysEnabledModules = new HashSet<>(); private static final Set disabledModules = new HashSet<>(); private static final Set optionalModules = Collections.unmodifiableSet(new HashSet<>(Arrays.asList( "disable-attack-sounds", "disable-sword-sweep-particles" ))); private static final Set internalModules = Collections.unmodifiableSet(new HashSet<>(Arrays.asList( "modeset-listener", "attack-cooldown-tracker", "entity-damage-listener" ))); public static void initialise(OCMMain plugin) { Config.plugin = plugin; config = plugin.getConfig(); // Make sure to separately call reload() } /** * @return Whether config was changed or not */ private static boolean checkConfigVersion() { final YamlConfiguration defaultConfig = YamlConfiguration.loadConfiguration( new InputStreamReader(Objects.requireNonNull(plugin.getResource(CONFIG_NAME)))); if (config.getInt("config-version") != defaultConfig.getInt("config-version")) { plugin.upgradeConfig(); reload(); return true; } return false; } public static void reload() { if (plugin.doesConfigExist()) { plugin.reloadConfig(); config = plugin.getConfig(); } else plugin.upgradeConfig(); // checkConfigVersion will call #reload() again anyways if (checkConfigVersion()) return; Messenger.reloadConfig(config.getBoolean("debug.enabled"), config.getString("message-prefix")); WeaponDamages.initialise(plugin); //Reload weapon damages from config reloadModesets(); reloadWorlds(); //Set EntityDamagedByEntityListener to enabled if either of these modules is enabled final EntityDamageByEntityListener EDBEL = EntityDamageByEntityListener.getINSTANCE(); if (EDBEL != null) { EDBEL.setEnabled(moduleEnabled("old-tool-damage") || moduleEnabled("old-potion-effects") || moduleEnabled("old-critical-hits") ); } // Dynamically registers / unregisters all event listeners for optimal performance! ModuleLoader.toggleModules(); ModuleLoader.getModules().forEach(module -> { try { module.reload(); } catch (Exception e) { plugin.getLogger() .log(Level.WARNING, "Error reloading module '" + module.toString() + "'", e); } }); } private static void reloadModesets() { modesets.clear(); alwaysEnabledModules.clear(); disabledModules.clear(); final Set moduleNames = ModuleLoader.getModules().stream() .map(OCMModule::getConfigName) .map(Config::normaliseModuleName) .collect(Collectors.toSet()); final Set knownModuleNames = new HashSet<>(moduleNames); knownModuleNames.addAll(optionalModules); final Set configurableModuleNames = new HashSet<>(knownModuleNames); configurableModuleNames.removeAll(internalModules); final ConfigurationSection modesetsSection = config.getConfigurationSection("modesets"); if (modesetsSection == null) { throw new IllegalStateException("Missing 'modesets' section in config. Every module must be assigned to a modeset, always_enabled_modules, or disabled_modules."); } final List errors = new ArrayList<>(); // A set to keep track of all the modules that are already in a modeset final Set modulesInModesets = new HashSet<>(); final List alwaysModules = config.getStringList("always_enabled_modules"); for (String moduleName : alwaysModules) { final String normalised = normaliseModuleName(moduleName); if (internalModules.contains(normalised)) { errors.add("Internal module should not be configured: " + moduleName); continue; } if (!configurableModuleNames.contains(normalised)) { Messenger.warn("Unknown module in always_enabled_modules: " + moduleName); continue; } alwaysEnabledModules.add(normalised); } final List disabledModuleList = config.getStringList("disabled_modules"); for (String moduleName : disabledModuleList) { final String normalised = normaliseModuleName(moduleName); if (internalModules.contains(normalised)) { errors.add("Internal module should not be configured: " + moduleName); continue; } if (!configurableModuleNames.contains(normalised)) { Messenger.warn("Unknown module in disabled_modules: " + moduleName); continue; } disabledModules.add(normalised); } for (String moduleName : alwaysEnabledModules) { if (disabledModules.contains(moduleName)) { errors.add("Module listed in both always_enabled_modules and disabled_modules: " + moduleName); } } // Iterate over each modeset for (String key : modesetsSection.getKeys(false)) { // Retrieve the list of module names for the current modeset final List moduleList = modesetsSection.getStringList(key); final Set moduleSet = new HashSet<>(); for (String moduleName : moduleList) { final String normalised = normaliseModuleName(moduleName); if (internalModules.contains(normalised)) { errors.add("Internal module should not be configured: " + moduleName); continue; } if (!configurableModuleNames.contains(normalised)) { Messenger.warn("Unknown module in modeset '%s': %s", key, moduleName); continue; } if (disabledModules.contains(normalised)) { errors.add("Module listed in disabled_modules and modeset '" + key + "': " + moduleName); continue; // skip to next module name } if (alwaysEnabledModules.contains(normalised)) { errors.add("Module listed in always_enabled_modules and modeset '" + key + "': " + moduleName); continue; } moduleSet.add(normalised); } // Add the current modeset and its modules to the map modesets.put(key, moduleSet); // Add all modules in the current modeset to the tracking set modulesInModesets.addAll(moduleSet); } for (String moduleName : configurableModuleNames) { if (disabledModules.contains(moduleName)) { continue; } if (alwaysEnabledModules.contains(moduleName)) { continue; } if (modulesInModesets.contains(moduleName)) { continue; } errors.add("Module not assigned to any list: " + moduleName); } if (!errors.isEmpty()) { final String message = "Invalid module assignment configuration:\n - " + String.join("\n - ", errors) + "\nEvery module must appear in exactly one of always_enabled_modules, disabled_modules, or modesets."; throw new IllegalStateException(message); } alwaysEnabledModules.addAll(internalModules); } private static void reloadWorlds() { worlds.clear(); final ConfigurationSection worldsSection = config.getConfigurationSection("worlds"); // Iterate over each world for (String worldName : worldsSection.getKeys(false)) { final World world = Bukkit.getWorld(worldName); if(world == null){ Messenger.warn("Configured world " + worldName + " not found, skipping (might be loaded later?)..."); continue; } addWorld(world, worldsSection); } } public static void addWorld(World world){ final ConfigurationSection worldsSection = config.getConfigurationSection("worlds"); addWorld(world, worldsSection); } public static void addWorld(World world, ConfigurationSection worldsSection) { // Retrieve the list of modeset names for the current world // Using a linkedhashset to remove duplicates but retain insertion order (important for default modeset) final LinkedHashSet modesetsSet = new LinkedHashSet<>(worldsSection.getStringList(world.getName())); // Add the current world and its modesets to the map worlds.put(world.getUID(), modesetsSet); } public static void removeWorld(World world){ worlds.remove(world.getUID()); } /** * Get the default modeset for the given world. * @param worldId The UUID for the world to check the allowed modesets for * @return The default modeset, if found. Otherwise null. */ public static @Nullable Set getDefaultModeset(UUID worldId){ if(!worlds.containsKey(worldId)) return null; final Set set = worlds.get(worldId); if(set == null || set.isEmpty()) return null; final Iterator iterator = set.iterator(); if(iterator.hasNext()) { final String modesetName = iterator.next(); if(modesets.containsKey(modesetName)){ return modesets.get(modesetName); } } return null; } /** * Checks whether the module is present in the default modeset for the specified world * @param world The world to get the default modeset for * @return Whether the module is enabled for the found modeset */ public static boolean moduleEnabled(String moduleName, World world) { final String normalised = normaliseModuleName(moduleName); if (disabledModules.contains(normalised)) return false; if (alwaysEnabledModules.contains(normalised)) return true; if (world == null) return isModuleInAnyModeset(normalised); // Only checking if module is globally enabled final Set defaultModeset = getDefaultModeset(world.getUID()); // If no default modeset found, the module should be enabled if(defaultModeset == null){ return isModuleInAnyModeset(normalised); } // Check if module is in default modeset return defaultModeset.contains(normalised); } /** * Check if module is globally enable under its own config section * @param moduleName The name of the module to check * @return Whether the module has enabled: true in its config section */ public static boolean moduleEnabled(String moduleName) { return moduleEnabled(moduleName, null); } public static boolean debugEnabled() { return config.getBoolean("debug.enabled"); } public static boolean moduleSettingEnabled(String moduleName, String moduleSettingName) { return config.getBoolean(moduleName + "." + moduleSettingName); } /** * Only use if you can't access config through plugin instance * * @return config.yml instance */ public static FileConfiguration getConfig() { return plugin.getConfig(); } public static Map> getModesets(){ return modesets; } public static boolean isModuleAlwaysEnabled(String moduleName) { return alwaysEnabledModules.contains(normaliseModuleName(moduleName)); } public static boolean isModuleDisabled(String moduleName) { return disabledModules.contains(normaliseModuleName(moduleName)); } public static boolean isModuleInAnyModeset(String moduleName) { return modesets.values().stream().anyMatch(set -> set.contains(normaliseModuleName(moduleName))); } public static Map> getWorlds() { return worlds; } private static String normaliseModuleName(String moduleName) { return moduleName == null ? "" : moduleName.toLowerCase(Locale.ROOT); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/ConfigUtils.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; import com.cryptomorin.xseries.XMaterial; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionDurations; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionKey; import org.bukkit.Material; import org.bukkit.configuration.ConfigurationSection; import java.util.*; import java.util.function.Predicate; import java.util.stream.Collectors; /** * Various utilities for making it easier to work with {@link org.bukkit.configuration.Configuration Configurations}. * * @see org.bukkit.configuration.file.YamlConfiguration * @see org.bukkit.configuration.ConfigurationSection */ public class ConfigUtils { private static final Set warnedUnknownPotionDurationKeys = Collections.synchronizedSet(new HashSet<>()); private static final Set warnedUnknownMaterialListKeys = Collections.synchronizedSet(new HashSet<>()); private static final Set warnedUnknownMaterialMapKeys = Collections.synchronizedSet(new HashSet<>()); /** * Safely loads all doubles from a configuration section, reading both double and integer values. * * @param section The section from which to load the doubles. * @return The map of doubles. */ public static Map loadDoubleMap(ConfigurationSection section) { Objects.requireNonNull(section, "section cannot be null!"); return section.getKeys(false).stream() .filter(((Predicate) section::isDouble).or(section::isInt)) .collect(Collectors.toMap(key -> key, section::getDouble)); } /** * Loads a material-to-double map from a configuration section. * Safely ignores non-matching materials. * * @param section The section from which to load the values. * @return The loaded material map. */ public static Map loadMaterialDoubleMap(ConfigurationSection section) { Objects.requireNonNull(section, "section cannot be null!"); final String fullKey = section.getCurrentPath() == null ? "" : section.getCurrentPath(); return section.getKeys(false).stream() .filter(((Predicate) section::isDouble).or(section::isInt)) .map(key -> { Material material = matchMaterial(key); if (material == null && isUnknownMaterialKey(key)) { warnUnknownMaterialMap(fullKey, key); return null; } if (material == null) { return null; } return new AbstractMap.SimpleImmutableEntry<>(material, section.getDouble(key)); }) .filter(Objects::nonNull) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (left, right) -> right)); } /** * Loads the list of {@link Material Materials} with the given key from a configuration section. * Safely ignores non-matching materials. * * @param section The section from which to load the material list. * @param key The key of the material list. * @return The loaded material list, or an empty list if there is no list at the given key. */ public static List loadMaterialList(ConfigurationSection section, String key) { Objects.requireNonNull(section, "section cannot be null!"); Objects.requireNonNull(key, "key cannot be null!"); if (!section.isList(key)) return new ArrayList<>(); final String basePath = section.getCurrentPath(); final String fullKey = basePath == null || basePath.isEmpty() ? key : basePath + "." + key; return section.getStringList(key).stream() .map(String::trim) .map(name -> { Material material = matchMaterial(name); if (material == null && isUnknownMaterialKey(name)) { warnUnknownMaterial(fullKey, name); return null; } return material; }) .filter(Objects::nonNull) .collect(Collectors.toList()); } private static void warnUnknownMaterial(String fullKey, String name) { final String warnKey = fullKey + ":" + name.toUpperCase(Locale.ROOT); if (warnedUnknownMaterialListKeys.add(warnKey)) { Messenger.warn("Unknown material '%s' in config list '%s'; skipping", name, fullKey); } } private static void warnUnknownMaterialMap(String fullKey, String name) { final String warnKey = fullKey + ":" + name.toUpperCase(Locale.ROOT); if (warnedUnknownMaterialMapKeys.add(warnKey)) { Messenger.warn("Unknown material '%s' in config section '%s'; skipping", name, fullKey); } } private static Material matchMaterial(String name) { Optional match = XMaterial.matchXMaterial(name); if (match.isPresent()) { return match.get().parseMaterial(); } return Material.matchMaterial(name); } private static boolean isUnknownMaterialKey(String name) { return !XMaterial.matchXMaterial(name).isPresent() && Material.matchMaterial(name) == null; } /** * Gets potion duration values from config for all configured potion types. * Will create map of potion keys to durations. * * @param section The section from which to load the duration values * @return HashMap of {@link String} and {@link PotionDurations} */ public static HashMap loadPotionDurationsList(ConfigurationSection section) { Objects.requireNonNull(section, "potion durations section cannot be null!"); final HashMap durationsHashMap = new HashMap<>(); final ConfigurationSection durationsSection = section.getConfigurationSection("potion-durations"); final ConfigurationSection drinkableSection = durationsSection.getConfigurationSection("drinkable"); final ConfigurationSection splashSection = durationsSection.getConfigurationSection("splash"); for (String newPotionTypeName : drinkableSection.getKeys(false)) { // Get durations in seconds and convert to ticks final int drinkableDuration = drinkableSection.getInt(newPotionTypeName) * 20; final int splashDuration = splashSection.getInt(newPotionTypeName) * 20; Optional potionKey = PotionKey.fromConfigKey(newPotionTypeName); if (potionKey.isPresent()) { durationsHashMap.put(potionKey.get(), new PotionDurations(drinkableDuration, splashDuration)); } else if (warnedUnknownPotionDurationKeys.add(newPotionTypeName)) { Messenger.warn("Unknown potion type '%s' in old-potion-effects.potion-durations; skipping", newPotionTypeName); } } return durationsHashMap; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/EventRegistry.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; import org.bukkit.event.HandlerList; import org.bukkit.event.Listener; import org.bukkit.plugin.Plugin; import java.util.ArrayList; import java.util.List; /** * A simple utility class to ensure that a Listener is not registered more than once. */ public class EventRegistry { private final Plugin plugin; private final List listeners = new ArrayList<>(); public EventRegistry(Plugin plugin) { this.plugin = plugin; } /** * Registers a listener and returns true if the listener was not already registered. * * @param listener The {@link Listener} to register. * @return Whether the listener was successfully registered. */ public boolean registerListener(Listener listener) { if (listeners.contains(listener)) return false; listeners.add(listener); plugin.getServer().getPluginManager().registerEvents(listener, plugin); return true; } /** * Unregisters a listener and returns true if the listener was already registered. * * @param listener The {@link Listener} to register. * @return Whether the listener was successfully unregistered. */ public boolean unregisterListener(Listener listener) { if (!listeners.contains(listener)) return false; listeners.remove(listener); HandlerList.unregisterAll(listener); return true; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/MathsHelper.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; /** * For all the maths utilities that I needed which (for some reason) aren't in the Math class. */ public class MathsHelper { /** * Clamps a value between a minimum and a maximum. * * @param value The value to clamp. * @param min The minimum value to clamp to. * @param max The maximum value to clamp to. * @return The clamped value. */ public static double clamp(double value, double min, double max) { return Math.max(Math.min(value, max), min); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/Messenger.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bukkit.ChatColor; import org.bukkit.command.CommandSender; import java.util.Objects; import java.util.logging.Level; public class Messenger { public static final String HORIZONTAL_BAR = ChatColor.STRIKETHROUGH + "----------------------------------------------------"; private static OCMMain plugin; private static boolean DEBUG_ENABLED = false; private static String PREFIX = "&6[OCM]&r"; public static void initialise(OCMMain plugin) { Messenger.plugin = plugin; } public static void reloadConfig(boolean debugEnabled, String prefix){ DEBUG_ENABLED = debugEnabled; PREFIX = prefix; } public static void info(String message, Object... args) { plugin.getLogger().info(TextUtils.stripColour(String.format(message, args))); } public static void warn(Throwable e, String message, Object... args) { plugin.getLogger().log(Level.WARNING, TextUtils.stripColour(String.format(message, args)), e); } public static void warn(String message, Object... args) { plugin.getLogger().log(Level.WARNING, TextUtils.stripColour(String.format(message, args))); } /** * This will format any ampersand (&) color codes, * format any args passed to it using {@link String#format(String, Object...)}, * and then send the message to the specified {@link CommandSender}. * * @param sender The {@link CommandSender} to send the message to. * @param message The message to send. * @param args The args to format the message with. */ public static void sendNoPrefix(CommandSender sender, String message, Object... args) { Objects.requireNonNull(sender, "sender cannot be null!"); Objects.requireNonNull(message, "message cannot be null!"); // Prevents sending of individual empty messages, allowing for selective message disabling. if (message.isEmpty()) return; sender.sendMessage(TextUtils.colourise(String.format(message, args))); } /** * This will add the prefix to the message, format any ampersand (&) color codes, * format any args passed to it using {@link String#format(String, Object...)}, * and then send the message to the specified {@link CommandSender}. * * @param sender The {@link CommandSender} to send the message to. * @param message The message to send. * @param prefix The prefix to the message * @param args The args to format the message with. */ private static void sendWithPrefix(CommandSender sender, String message, String prefix, Object... args) { // Prevents sending of individual empty messages, allowing for selective message disabling. if (message.isEmpty()) return; sendNoPrefix(sender, prefix + " " + message, args); } public static void send(CommandSender sender, String message, Object... args) { sendWithPrefix(sender, message, PREFIX, args); } private static void sendDebugMessage(CommandSender sender, String message, Object... args) { sendWithPrefix(sender, message, "&1[Debug]&r", args); } public static void debug(String message, Throwable throwable) { if (DEBUG_ENABLED) plugin.getLogger().log(Level.INFO, message, throwable); } public static void debug(String message, Object... args) { if (DEBUG_ENABLED) info("[DEBUG] " + message, args); } public static void debug(CommandSender sender, String message, Object... args) { if (DEBUG_ENABLED) sendDebugMessage(sender, message, args); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/TextUtils.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities; import org.bukkit.ChatColor; public class TextUtils { /** * Converts ampersand (&) color codes to Minecraft ({@link ChatColor#COLOR_CHAR}) color codes. * * @param text The text to colourise. * @return The colourised text. */ public static String colourise(String text) { return ChatColor.translateAlternateColorCodes('&', text); } /** * Removes all Minecraft ({@link ChatColor#COLOR_CHAR}) colour codes from a string. * * @param text The text to strip colours from. * @return The stripped text. */ public static String stripColour(String text) { return ChatColor.stripColor(text); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/AttackCooldownTracker.java ================================================ package kernitus.plugin.OldCombatMechanics.utilities.damage; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import kernitus.plugin.OldCombatMechanics.utilities.reflection.VersionCompatUtils; import org.bukkit.Bukkit; import org.bukkit.entity.HumanEntity; import org.bukkit.event.EventHandler; import org.bukkit.event.player.PlayerQuitEvent; import java.util.HashMap; import java.util.Map; import java.util.UUID; /** * Spigot versions below 1.16 did not have way of getting attack cooldown. * Obtaining through NMS works, but value is reset before EntityDamageEvent is called. * This means we must keep track of the cooldown to get the correct values. */ public class AttackCooldownTracker extends OCMModule { private static AttackCooldownTracker INSTANCE; private final Map lastCooldown; public AttackCooldownTracker(OCMMain plugin) { super(plugin, "attack-cooldown-tracker"); lastCooldown = new HashMap<>(); // This module only matters on versions where HumanEntity#getAttackCooldown does not exist (pre-1.16). // OCMMain already gates registration via feature detection, but keep this as a safety net in case a // fork/backport adds the method or another plugin initialises this module manually. if (Reflector.getMethod(HumanEntity.class, "getAttackCooldown", 0) != null) { INSTANCE = null; return; } INSTANCE = this; Runnable cooldownTask = () -> Bukkit.getOnlinePlayers().forEach( player -> lastCooldown.put(player.getUniqueId(), VersionCompatUtils.getAttackCooldown(player) )); // Performance: one global per-tick task, not per-player. We must sample every tick because the NMS value // is reset before the Bukkit damage event fires, so on-demand reads would be incorrect. Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, cooldownTask, 0, 1L); } @EventHandler public void onPlayerQuit(PlayerQuitEvent event){ lastCooldown.remove(event.getPlayer().getUniqueId()); } public static Float getLastCooldown(UUID uuid) { final AttackCooldownTracker instance = INSTANCE; if (instance == null) return null; return instance.lastCooldown.get(uuid); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/DamageUtils.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser; import org.bukkit.Material; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; public class DamageUtils { // Method added in 1.16.4 private static final SpigotFunctionChooser isInWater = SpigotFunctionChooser.apiCompatCall( (le, params) -> le.isInWater(), (le, params) -> le.getLocation().getBlock().getType() == Material.WATER ); // Method added in 1.17.0 private static final SpigotFunctionChooser isClimbing = SpigotFunctionChooser.apiCompatCall( (le, params) -> le.isClimbing(), (le, params) -> { final Material material = le.getLocation().getBlock().getType(); return material == Material.LADDER || material == Material.VINE; } ); // Method added in 1.16. Default parameter for reflected method is 0.5F public static final SpigotFunctionChooser getAttackCooldown = SpigotFunctionChooser.apiCompatCall( (he, params) -> he.getAttackCooldown(), (he, params) -> getAttackCooldown(he) ); /** * Gets last stored attack cooldown. Used when method is not available and we are keeping track of value ourselves. * @param humanEntity The player to get the attack cooldown from * @return The attack cooldown, as a value between 0 and 1 */ private static float getAttackCooldown(HumanEntity humanEntity){ final Float cooldown = AttackCooldownTracker.getLastCooldown(humanEntity.getUniqueId()); if(cooldown == null){ Messenger.debug("Last attack cooldown null for " + humanEntity.getName() + ", assuming full attack strength"); return 1L; } return cooldown; } /** * Get sharpness damage multiplier for 1.9 * * @param level The level of the enchantment * @return Sharpness damage multiplier */ public static double getNewSharpnessDamage(int level) { return level >= 1 ? 1 + (level - 1) * 0.5 : 0; } /** * Get sharpness damage multiplier for 1.8 * * @param level The level of the enchantment * @return Sharpness damage multiplier */ public static double getOldSharpnessDamage(int level) { return level >= 1 ? level * 1.25 : 0; } /** * Check preconditions for critical hit * * @param humanEntity Living entity to perform checks on * @return Whether hit is critical */ public static boolean isCriticalHit1_8(HumanEntity humanEntity) { /* Code from Bukkit 1.8_R3: boolean flag = this.fallDistance > 0.0F && !this.onGround && !this.onClimbable() && !this.isInWater() && !this.hasEffect(MobEffectList.BLINDNESS) && this.vehicle == null && entity instanceof EntityLiving; */ return humanEntity.getFallDistance() > 0.0F && !humanEntity.isOnGround() && !isClimbing.apply(humanEntity) && !isInWater.apply(humanEntity) && humanEntity.getActivePotionEffects().stream().map(PotionEffect::getType) .noneMatch(e -> e == PotionEffectType.BLINDNESS) && !humanEntity.isInsideVehicle(); } public static boolean isCriticalHit1_9(Player player) { return isCriticalHit1_8(player) && getAttackCooldown.apply(player) > 0.9F && !player.isSprinting(); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/DefenceUtils.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import com.cryptomorin.xseries.XAttribute; import com.cryptomorin.xseries.XEnchantment; import com.cryptomorin.xseries.XPotion; import kernitus.plugin.OldCombatMechanics.utilities.reflection.Reflector; import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser; import kernitus.plugin.OldCombatMechanics.utilities.reflection.VersionCompatUtils; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.attribute.AttributeModifier; import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.LivingEntity; import org.bukkit.event.entity.EntityDamageEvent; import org.bukkit.inventory.EquipmentSlot; import org.bukkit.inventory.ItemStack; import java.util.Collection; import java.util.EnumSet; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.concurrent.ThreadLocalRandom; import java.util.function.Supplier; import static kernitus.plugin.OldCombatMechanics.utilities.Messenger.debug; /** * Utilities for calculating damage reduction from armour and status effects. * Defence order is armour defence -> resistance -> armour enchants -> * absorption * BASE -> HARD_HAT -> BLOCKING -> ARMOUR -> RESISTANCE -> MAGIC -> ABSORPTION * This class just deals with everything from armour onwards */ public class DefenceUtils { private static final double REDUCTION_PER_ARMOUR_POINT = 0.04; private static final double REDUCTION_PER_RESISTANCE_LEVEL = 0.2; private static final Set ARMOUR_IGNORING_CAUSES = EnumSet.of( EntityDamageEvent.DamageCause.FIRE_TICK, EntityDamageEvent.DamageCause.SUFFOCATION, EntityDamageEvent.DamageCause.DROWNING, EntityDamageEvent.DamageCause.STARVATION, EntityDamageEvent.DamageCause.FALL, EntityDamageEvent.DamageCause.VOID, EntityDamageEvent.DamageCause.CUSTOM, EntityDamageEvent.DamageCause.MAGIC, EntityDamageEvent.DamageCause.WITHER, // From 1.9 EntityDamageEvent.DamageCause.FLY_INTO_WALL, EntityDamageEvent.DamageCause.DRAGON_BREATH // In 1.19 FIRE bypasses armour, but it doesn't in 1.8 so we don't add it here ); private static final Set warnedUnknownArmourEnchants = new HashSet<>(); private static final Set VANILLA_ENCHANTMENTS = initVanillaEnchantments(); // Stalagmite ignores armour but other blocks under CONTACT do not, explicitly // checked below static { if (Reflector.versionIsNewerOrEqualTo(1, 11, 0)) ARMOUR_IGNORING_CAUSES.add(EntityDamageEvent.DamageCause.CRAMMING); if (Reflector.versionIsNewerOrEqualTo(1, 17, 0)) ARMOUR_IGNORING_CAUSES.add(EntityDamageEvent.DamageCause.FREEZE); } // Method added in 1.15 private static final SpigotFunctionChooser getAbsorptionAmount = SpigotFunctionChooser .apiCompatCall( (le, params) -> le.getAbsorptionAmount(), (le, params) -> Double.valueOf(VersionCompatUtils.getAbsorptionAmount(le))); /** * Calculates the reduction by armour, resistance, armour enchantments and * absorption. * The values are updated directly in the map for each damage modifier. * * @param damagedEntity The entity that was damaged * @param damageModifiers A map of the damage modifiers and their values from * the event * @param damageCause The cause of the damage */ @SuppressWarnings("deprecation") public static void calculateDefenceDamageReduction(LivingEntity damagedEntity, Map damageModifiers, EntityDamageEvent.DamageCause damageCause, boolean randomness) { final double armourPoints = damagedEntity.getAttribute(XAttribute.ARMOR.get()).getValue(); // Make sure we don't go over 100% protection final double armourReductionFactor = Math.min(1.0, armourPoints * REDUCTION_PER_ARMOUR_POINT); // applyArmorModifier() calculations from NMS // Apply armour damage reduction after hard hat (wearing helmet & hit by block) // and blocking reduction double currentDamage = damageModifiers.get(EntityDamageEvent.DamageModifier.BASE) + damageModifiers.getOrDefault(EntityDamageEvent.DamageModifier.HARD_HAT, 0.0) + damageModifiers.getOrDefault(EntityDamageEvent.DamageModifier.BLOCKING, 0.0); if (damageModifiers.containsKey(EntityDamageEvent.DamageModifier.ARMOR)) { double armourReduction = 0; // If the damage cause does not ignore armour // If the block they are in is a stalagmite, also ignore armour if (!ARMOUR_IGNORING_CAUSES.contains(damageCause) && !(Reflector.versionIsNewerOrEqualTo(1, 19, 0) && damageCause == EntityDamageEvent.DamageCause.CONTACT && damagedEntity.getLocation().getBlock().getType() == Material.POINTED_DRIPSTONE)) { armourReduction = currentDamage * -armourReductionFactor; } damageModifiers.put(EntityDamageEvent.DamageModifier.ARMOR, armourReduction); currentDamage += armourReduction; } // This is the applyMagicModifier() calculations from NMS if (damageCause != EntityDamageEvent.DamageCause.STARVATION) { // Apply resistance effect if (damageModifiers.containsKey(EntityDamageEvent.DamageModifier.RESISTANCE) && damageCause != EntityDamageEvent.DamageCause.VOID && damagedEntity.hasPotionEffect(XPotion.RESISTANCE.get())) { final int level = damagedEntity.getPotionEffect(XPotion.RESISTANCE.get()).getAmplifier() + 1; // Make sure we don't go over 100% protection final double resistanceReductionFactor = Math.min(1.0, level * REDUCTION_PER_RESISTANCE_LEVEL); final double resistanceReduction = -resistanceReductionFactor * currentDamage; damageModifiers.put(EntityDamageEvent.DamageModifier.RESISTANCE, resistanceReduction); currentDamage += resistanceReduction; } // Apply armour enchants // Don't calculate enchants if damage already 0 (like 1.8 NMS). Enchants cap at // 80% reduction if (currentDamage > 0 && damageModifiers.containsKey(EntityDamageEvent.DamageModifier.MAGIC)) { final double enchantsReductionFactor = calculateArmourEnchantmentReductionFactor( damagedEntity.getEquipment().getArmorContents(), damageCause, randomness); final double enchantsReduction = currentDamage * -enchantsReductionFactor; damageModifiers.put(EntityDamageEvent.DamageModifier.MAGIC, enchantsReduction); currentDamage += enchantsReduction; } // Absorption if (damageModifiers.containsKey(EntityDamageEvent.DamageModifier.ABSORPTION)) { final double absorptionAmount = getAbsorptionAmount.apply(damagedEntity); double absorptionReduction = -Math.min(absorptionAmount, currentDamage); damageModifiers.put(EntityDamageEvent.DamageModifier.ABSORPTION, absorptionReduction); } } } /** * Return the damage after applying armour, resistance, and armour enchants * protections, following 1.8 algorithm. * * @param defender The entity that is being attacked * @param baseDamage The base damage done by the event, including weapon * enchants, potions, crits * @param armourContents The 4 pieces of armour contained in the armour slots * @param damageCause The source of damage * @param randomness Whether to apply random multiplier * @return The damage done to the entity after armour is taken into account */ public static double getDamageAfterArmour1_8(LivingEntity defender, double baseDamage, ItemStack[] armourContents, EntityDamageEvent.DamageCause damageCause, boolean randomness) { double armourPoints = 0; for (int i = 0; i < armourContents.length; i++) { final ItemStack itemStack = armourContents[i]; if (itemStack == null) continue; final EquipmentSlot slot = new EquipmentSlot[] { EquipmentSlot.FEET, EquipmentSlot.LEGS, EquipmentSlot.CHEST, EquipmentSlot.HEAD }[i]; armourPoints += getAttributeModifierSum(itemStack.getType().getDefaultAttributeModifiers(slot) .get(XAttribute.ARMOR.get())); } final double reductionFactor = armourPoints * REDUCTION_PER_ARMOUR_POINT; // Apply armour damage reduction double finalDamage = baseDamage - (ARMOUR_IGNORING_CAUSES.contains(damageCause) ? 0 : (baseDamage * reductionFactor)); // Calculate resistance if (defender.hasPotionEffect(XPotion.RESISTANCE.get())) { int resistanceLevel = defender.getPotionEffect(XPotion.RESISTANCE.get()).getAmplifier() + 1; finalDamage *= 1.0 - (resistanceLevel * 0.2); } // Don't calculate enchantment reduction if damage is already 0. NMS 1.8 does it // this way. final double enchantmentReductionFactor = calculateArmourEnchantmentReductionFactor(armourContents, damageCause, randomness); if (finalDamage > 0) { finalDamage -= finalDamage * enchantmentReductionFactor; } debug("Reductions: Armour %.0f%%, Ench %.0f%%, Total %.2f%%, Start dmg: %.2f Final: %.2f", reductionFactor * 100, enchantmentReductionFactor * 100, (reductionFactor + (1 - reductionFactor) * enchantmentReductionFactor) * 100, baseDamage, finalDamage); return finalDamage; } /** * Applies all the operations for the attribute modifiers of a specific * attribute. * Does not take into account the base value. */ private static double getAttributeModifierSum(Collection modifiers) { double sum = 0; for (AttributeModifier modifier : modifiers) { final double value = modifier.getAmount(); switch (modifier.getOperation()) { case ADD_SCALAR: sum += Math.abs(value); break; case ADD_NUMBER: sum += value; break; case MULTIPLY_SCALAR_1: sum *= value; break; } } return sum; } private static double calculateArmourEnchantmentReductionFactor(ItemStack[] armourContents, EntityDamageEvent.DamageCause cause, boolean randomness) { int totalEpf = 0; for (ItemStack armourItem : armourContents) { if (armourItem != null && armourItem.getType() != Material.AIR) { warnOnUnknownArmourEnchantments(armourItem); for (EnchantmentType enchantmentType : EnchantmentType.values()) { if (!enchantmentType.protectsAgainst(cause)) continue; int enchantmentLevel = armourItem.getEnchantmentLevel(enchantmentType.getEnchantment()); if (enchantmentLevel > 0) { totalEpf += enchantmentType.getEpf(enchantmentLevel); } } } } // Cap at 25 totalEpf = Math.min(25, totalEpf); // Multiply by random value between 50% and 100%, then round up double multiplier = randomness ? ThreadLocalRandom.current().nextDouble(0.5, 1) : 1.0; totalEpf = (int) Math.ceil(totalEpf * multiplier); // Cap at 20 totalEpf = Math.min(20, totalEpf); return REDUCTION_PER_ARMOUR_POINT * totalEpf; } private static void warnOnUnknownArmourEnchantments(ItemStack armourItem) { if (armourItem.getEnchantments().isEmpty()) { return; } for (Enchantment enchantment : armourItem.getEnchantments().keySet()) { if (enchantment == null || isModelledArmourEnchantment(enchantment)) { continue; } if (!shouldWarnOnUnknownEnchantment(enchantment)) { continue; } final String name = enchantment.getName(); if (warnedUnknownArmourEnchants.add(name)) { kernitus.plugin.OldCombatMechanics.utilities.Messenger.warn( "Armour enchantment '%s' is not modelled by OCM damage reduction; results may differ", name); } } } private static boolean shouldWarnOnUnknownEnchantment(Enchantment enchantment) { try { final NamespacedKey key = enchantment.getKey(); if (key != null) { return !"minecraft".equals(key.getNamespace()); } } catch (NoSuchMethodError | NoClassDefFoundError ignored) { // Legacy servers do not expose NamespacedKey; fall back to known vanilla list. } return !isVanillaEnchantment(enchantment); } private static Set initVanillaEnchantments() { final Set enchantments = new HashSet<>(); for (XEnchantment xEnchantment : XEnchantment.values()) { final Enchantment enchantment = xEnchantment.getEnchant(); if (enchantment != null) { enchantments.add(enchantment); } } return enchantments; } private static boolean isVanillaEnchantment(Enchantment enchantment) { return VANILLA_ENCHANTMENTS.contains(enchantment); } private static boolean isModelledArmourEnchantment(Enchantment enchantment) { for (EnchantmentType enchantmentType : EnchantmentType.values()) { if (enchantmentType.getEnchantment().equals(enchantment)) { return true; } } return false; } private enum EnchantmentType { // Data from https://minecraft.fandom.com/wiki/Armor#Mechanics PROTECTION(() -> { EnumSet damageCauses = EnumSet.of( EntityDamageEvent.DamageCause.CONTACT, EntityDamageEvent.DamageCause.ENTITY_ATTACK, EntityDamageEvent.DamageCause.PROJECTILE, EntityDamageEvent.DamageCause.FALL, EntityDamageEvent.DamageCause.FIRE, EntityDamageEvent.DamageCause.LAVA, EntityDamageEvent.DamageCause.BLOCK_EXPLOSION, EntityDamageEvent.DamageCause.ENTITY_EXPLOSION, EntityDamageEvent.DamageCause.LIGHTNING, EntityDamageEvent.DamageCause.POISON, EntityDamageEvent.DamageCause.MAGIC, EntityDamageEvent.DamageCause.WITHER, EntityDamageEvent.DamageCause.FALLING_BLOCK, EntityDamageEvent.DamageCause.THORNS, EntityDamageEvent.DamageCause.DRAGON_BREATH); if (Reflector.versionIsNewerOrEqualTo(1, 10, 0)) damageCauses.add(EntityDamageEvent.DamageCause.HOT_FLOOR); if (Reflector.versionIsNewerOrEqualTo(1, 12, 0)) damageCauses.add(EntityDamageEvent.DamageCause.ENTITY_SWEEP_ATTACK); return damageCauses; }, 0.75, XEnchantment.PROTECTION.getEnchant()), FIRE_PROTECTION(() -> { EnumSet damageCauses = EnumSet.of( EntityDamageEvent.DamageCause.FIRE, EntityDamageEvent.DamageCause.FIRE_TICK, EntityDamageEvent.DamageCause.LAVA); if (Reflector.versionIsNewerOrEqualTo(1, 10, 0)) { damageCauses.add(EntityDamageEvent.DamageCause.HOT_FLOOR); } return damageCauses; }, 1.25, XEnchantment.FIRE_PROTECTION.getEnchant()), BLAST_PROTECTION(() -> EnumSet.of( EntityDamageEvent.DamageCause.ENTITY_EXPLOSION, EntityDamageEvent.DamageCause.BLOCK_EXPLOSION), 1.5, XEnchantment.BLAST_PROTECTION.getEnchant()), PROJECTILE_PROTECTION(() -> EnumSet.of( EntityDamageEvent.DamageCause.PROJECTILE), 1.5, XEnchantment.PROJECTILE_PROTECTION.getEnchant()), FALL_PROTECTION(() -> EnumSet.of( EntityDamageEvent.DamageCause.FALL), 2.5, XEnchantment.FEATHER_FALLING.getEnchant()); private final Set protection; private final double typeModifier; private final Enchantment enchantment; EnchantmentType(Supplier> protection, double typeModifier, Enchantment enchantment) { this.protection = protection.get(); this.typeModifier = typeModifier; this.enchantment = enchantment; } /** * Returns whether the armour protects against the given damage cause. * * @param cause the damage cause * @return true if the armour protects against the given damage cause */ public boolean protectsAgainst(EntityDamageEvent.DamageCause cause) { return protection.contains(cause); } /** * Returns the bukkit enchantment. * * @return the bukkit enchantment */ public Enchantment getEnchantment() { return enchantment; } /** * Returns the enchantment protection factor (EPF). * * @param level the level of the enchantment * @return the EPF */ public int getEpf(int level) { // floor ( (6 + level^2) * TypeModifier / 3 ) return (int) Math.floor((6 + level * level) * typeModifier / 3); } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/EntityDamageByEntityListener.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import kernitus.plugin.OldCombatMechanics.module.ModuleSwordBlocking; import org.bukkit.Bukkit; import org.bukkit.entity.Entity; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.LivingEntity; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.entity.EntityDamageByEntityEvent; import org.bukkit.event.entity.EntityDamageEvent; import java.util.Map; import java.util.UUID; import java.util.HashMap; import java.util.Iterator; public class EntityDamageByEntityListener extends OCMModule { private static EntityDamageByEntityListener INSTANCE; private boolean enabled; private final Map lastDamages; private final Map lastDamageExpiryTicks; private long tickCounter; private int expirySweepTaskId = -1; private static final long EXPIRY_SWEEP_INTERVAL_TICKS = 20L; private static final long MIN_LAST_DAMAGE_TTL_TICKS = 20L; public EntityDamageByEntityListener(OCMMain plugin) { super(plugin, "entity-damage-listener"); INSTANCE = this; lastDamages = new HashMap<>(); lastDamageExpiryTicks = new HashMap<>(); } public static EntityDamageByEntityListener getINSTANCE() { return INSTANCE; } @Override public boolean isEnabled() { return enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; if (enabled) { startExpirySweeperIfNeeded(); } else { stopExpirySweeperIfNeeded(); lastDamages.clear(); lastDamageExpiryTicks.clear(); } } private void startExpirySweeperIfNeeded() { if (expirySweepTaskId != -1) return; expirySweepTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> { tickCounter++; if (tickCounter % EXPIRY_SWEEP_INTERVAL_TICKS != 0) return; sweepExpiredEntries(); }, 1L, 1L); } private void stopExpirySweeperIfNeeded() { if (expirySweepTaskId == -1) return; Bukkit.getScheduler().cancelTask(expirySweepTaskId); expirySweepTaskId = -1; } private void touchExpiry(LivingEntity damagee) { final UUID uuid = damagee.getUniqueId(); // Some implementations / test setups set maximumNoDamageTicks to 0, but damage immunity bookkeeping can // still matter for a short period (e.g. cancelled fire ticks during invulnerability). Keep a small minimum. final long delayTicks = Math.max(MIN_LAST_DAMAGE_TTL_TICKS, damagee.getMaximumNoDamageTicks()); final long candidateExpiry = tickCounter + delayTicks; final Long existingExpiry = lastDamageExpiryTicks.get(uuid); if (existingExpiry == null || candidateExpiry > existingExpiry) { lastDamageExpiryTicks.put(uuid, candidateExpiry); } } private void sweepExpiredEntries() { final Iterator> it = lastDamageExpiryTicks.entrySet().iterator(); while (it.hasNext()) { final Map.Entry entry = it.next(); if (entry.getValue() > tickCounter) continue; final UUID uuid = entry.getKey(); it.remove(); lastDamages.remove(uuid); } } @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true) public void onEntityDamage(EntityDamageEvent event) { final Entity damagee = event.getEntity(); if (!(event instanceof EntityDamageByEntityEvent)) { // Damage immunity only applies to living entities if (!(damagee instanceof LivingEntity)) return; final LivingEntity livingDamagee = ((LivingEntity) damagee); final Double storedDamage = lastDamages.get(livingDamagee.getUniqueId()); debug("Non-entity damage before restore: lastDamage=" + livingDamagee.getLastDamage() + " stored=" + storedDamage, livingDamagee); debug("Non-entity damage before restore: lastDamage=" + livingDamagee.getLastDamage() + " stored=" + storedDamage); restoreLastDamage(livingDamagee); debug("Non-entity damage after restore: lastDamage=" + livingDamagee.getLastDamage(), livingDamagee); debug("Non-entity damage after restore: lastDamage=" + livingDamagee.getLastDamage()); double newDamage = event.getDamage(); // base damage, before defence calculations // Overdamage due to immunity // Invulnerability will cause less damage if they attack with a stronger weapon while vulnerable // That is, the difference in damage will be dealt, but only if new attack is stronger than previous one newDamage = checkOverdamage(livingDamagee, event, newDamage); if (newDamage < 0) { debug("Damage was " + newDamage + " setting to 0"); newDamage = 0; } // Set damage, this should scale effects in the 1.9 way in case some of our modules are disabled event.setDamage(newDamage); debug("Attack damage (before defence): " + newDamage); } else { final Entity damager = ((EntityDamageByEntityEvent) event).getDamager(); // Call event constructor before setting lastDamage back, because we need it for calculations final OCMEntityDamageByEntityEvent e = new OCMEntityDamageByEntityEvent (damager, damagee, event.getCause(), event.getDamage()); // Set last damage to actual value for other modules and plugins to use // This will be set back to 0 in MONITOR listener on the next tick to detect all potential overdamages. // If there is large delay between last time an entity was damaged and the next damage, // the last damage might have been removed from the weak hash map. This is intended, as the immunity // ticks tends to be a short period of time anyway and last damage is irrelevant after immunity has expired. if (damagee instanceof LivingEntity) restoreLastDamage((LivingEntity) damagee); // Call event for the other modules to make their modifications plugin.getServer().getPluginManager().callEvent(e); if (e.isCancelled()) return; // Now we re-calculate damage modified by the modules and set it back to original event // Attack components order: (Base + Potion effects, scaled by attack delay) + Critical Hit + (Enchantments, scaled by attack delay) // Hurt components order: Overdamage - Armour - Resistance - Armour enchants - Absorption double newDamage = e.getBaseDamage(); debug("Base: " + e.getBaseDamage(), damager); debug("Base: " + e.getBaseDamage()); // Weakness potion final double weaknessModifier = e.getWeaknessModifier() * e.getWeaknessLevel(); final double weaknessAddend = e.isWeaknessModifierMultiplier() ? newDamage * weaknessModifier : weaknessModifier; // Don't modify newDamage yet so both potion effects are calculated off of the base damage debug("Weak: " + weaknessAddend); debug("Weak: " + weaknessAddend, damager); // Strength potion debug("Strength level: " + e.getStrengthLevel()); debug("Strength level: " + e.getStrengthLevel(), damager); double strengthModifier = e.getStrengthModifier() * e.getStrengthLevel(); if (!e.isStrengthModifierMultiplier()) newDamage += strengthModifier; else if (e.isStrengthModifierAddend()) newDamage *= ++strengthModifier; else newDamage *= strengthModifier; debug("Strength: " + strengthModifier); debug("Strength: " + strengthModifier, damager); newDamage += weaknessAddend; // Scale by attack delay // float currentItemAttackStrengthDelay = 1.0D / GenericAttributes.ATTACK_SPEED * 20.0D // attack strength ticker goes up by 1 every tick, is reset to 0 after an attack // float f2 = MathHelper.clamp((attackStrengthTicker + 0.5) / currentItemAttackStrengthDelay, 0.0F, 1.0F); // f *= 0.2F + f2 * f2 * 0.8F; // the multiplier is equivalent to y = 0.8x^2 + 0.2 // because x (f2) is always between 0 and 1, the multiplier will always be between 0.2 and 1 // this implies 40 speed is the minimum to always have full attack strength if (damager instanceof HumanEntity) { final float cooldown = DamageUtils.getAttackCooldown.apply((HumanEntity) damager, 0.5F); // i.e. f2 debug("Scale by attack delay: " + newDamage + " *= 0.2 + " + cooldown + "^2 * 0.8"); newDamage *= 0.2F + cooldown * cooldown * 0.8F; } // Critical hit final double criticalMultiplier = e.getCriticalMultiplier(); debug("Crit " + newDamage + " *= " + criticalMultiplier); newDamage *= criticalMultiplier; // Enchantment damage, scaled by attack cooldown double enchantmentDamage = e.getMobEnchantmentsDamage() + e.getSharpnessDamage(); if (damager instanceof HumanEntity) { final float cooldown = DamageUtils.getAttackCooldown.apply((HumanEntity) damager, 0.5F); debug("Scale enchantments by attack delay: " + enchantmentDamage + " *= " + cooldown); enchantmentDamage *= cooldown; } newDamage += enchantmentDamage; debug("Mob " + e.getMobEnchantmentsDamage() + " Sharp: " + e.getSharpnessDamage() + " Scaled: " + enchantmentDamage, damager); // Paper sword blocking (consumable-based, no shield) final ModuleSwordBlocking swordBlocking = ModuleSwordBlocking.getInstance(); double paperBlockReduction = 0; if (event instanceof EntityDamageByEntityEvent && swordBlocking != null) { paperBlockReduction = swordBlocking.applyPaperBlockingReduction((EntityDamageByEntityEvent) event, newDamage); if (paperBlockReduction > 0) { final double preBlockDamage = newDamage; newDamage = Math.max(0, newDamage - paperBlockReduction); ((EntityDamageByEntityEvent) event).setDamage(EntityDamageEvent.DamageModifier.BLOCKING, -paperBlockReduction); ((EntityDamageByEntityEvent) event).setDamage(EntityDamageEvent.DamageModifier.BASE, preBlockDamage); debug("Sword block (Paper): " + preBlockDamage + " - " + paperBlockReduction + " = " + newDamage, damager); } } if (damagee instanceof LivingEntity) { // Overdamage due to immunity // Invulnerability will cause less damage if they attack with a stronger weapon while vulnerable // That is, the difference in damage will be dealt, but only if new attack is stronger than previous one // Value before overdamage will become new "last damage" newDamage = checkOverdamage(((LivingEntity) damagee), event, newDamage); } if (newDamage < 0) { debug("Damage was " + newDamage + " setting to 0", damager); newDamage = 0; } // Set damage; if we already populated modifiers for blocking, avoid overwriting BASE. if (paperBlockReduction > 0 && event instanceof EntityDamageByEntityEvent) { ((EntityDamageByEntityEvent) event).setDamage(EntityDamageEvent.DamageModifier.BASE, newDamage + paperBlockReduction); // BLOCKING was set earlier; total damage is BASE + BLOCKING (+ others) } else { event.setDamage(newDamage); } debug("New Damage: " + newDamage, damager); debug("Attack damage (before defence): " + newDamage); } } /** * Set entity's last damage to 0 a tick after the event so all overdamage attacks get through. * The last damage is overridden by NMS code regardless of what the actual damage is set to via Spigot. * Finally, the LOWEST priority listener above will set the last damage back to the correct value * for other plugins to use the next time the entity is damaged. */ @EventHandler(priority = EventPriority.MONITOR) public void afterEntityDamage(EntityDamageEvent event) { final Entity damagee = event.getEntity(); if (event instanceof EntityDamageByEntityEvent) { if (damagee instanceof LivingEntity && lastDamages.containsKey(damagee.getUniqueId())) { // Set last damage to 0, so we can detect attacks even by weapons with a weaker attack value than what OCM would calculate Bukkit.getScheduler().runTaskLater(plugin, () -> { ((LivingEntity) damagee).setLastDamage(0); debug("Set last damage to 0", damagee); debug("Set last damage to 0"); }, 1L); } } else { // if not EDBYE then we leave last damage as is if (damagee instanceof LivingEntity) { final LivingEntity livingDamagee = (LivingEntity) damagee; if ((float) livingDamagee.getNoDamageTicks() > (float) livingDamagee.getMaximumNoDamageTicks() / 2.0F && lastDamages.containsKey(livingDamagee.getUniqueId())) { debug("Non-entity damage inside invulnerability window, keeping stored last damage", livingDamagee); debug("Non-entity damage inside invulnerability window, keeping stored last damage"); return; } clearStoredDamage(livingDamagee); } debug("Non-entity damage, using default last damage", damagee); debug("Non-entity damage, using default last damage"); } } /** * Restored the correct last damage for the given entity * * @param damagee The living entity to try to restore the last damage for */ private void restoreLastDamage(LivingEntity damagee) { final Double lastStoredDamage = resolveStoredDamage(damagee); if (lastStoredDamage != null) { final LivingEntity livingDamagee = damagee; livingDamagee.setLastDamage(lastStoredDamage); lastDamages.put(livingDamagee.getUniqueId(), lastStoredDamage); touchExpiry(livingDamagee); debug("Set last damage back to " + lastStoredDamage, livingDamagee); debug("Set last damage back to " + lastStoredDamage); } else { debug("No stored last damage to restore", damagee); debug("No stored last damage to restore"); } } private double checkOverdamage(LivingEntity livingDamagee, EntityDamageEvent event, double newDamage) { final double incomingDamage = newDamage; // base damage (before defence), used for baseline tracking final double newLastDamage = Math.max(0, incomingDamage); /* * Vanilla 1.12 EntityLiving#damageEntity(DamageSource, float) flow: * - If noDamageTicks > maxNoDamageTicks / 2: * - If damage <= lastDamage -> return false (cancel) * - Else call damageEntity0(source, damage - lastDamage) * - Then lastDamage = damage * - Else: * - Call damageEntity0(source, damage) * - lastDamage = damage * - Set noDamageTicks = maxNoDamageTicks, etc. * * This means any successful fire tick overwrites lastDamage, so we must restore * the correct baseline before applying our overdamage checks. */ if ((float) livingDamagee.getNoDamageTicks() > (float) livingDamagee.getMaximumNoDamageTicks() / 2.0F) { // Last damage was either set to correct value above in this listener, or we're using the server's value // If other plugins later modify BASE damage, they should either be taking last damage into account, // or ignoring the event if it is cancelled final Double storedDamage = resolveStoredDamage(livingDamagee); final double lastDamage = storedDamage != null ? storedDamage : livingDamagee.getLastDamage(); if (newDamage <= lastDamage) { event.setDamage(0); event.setCancelled(true); debug("Was fake overdamage, cancelling " + newDamage + " <= " + lastDamage); // Do not overwrite the stored baseline with this cancelled damage (e.g. fire tick), // otherwise the next attack can incorrectly bypass immunity. lastDamages.put(livingDamagee.getUniqueId(), lastDamage); touchExpiry(livingDamagee); return 0; } debug("Overdamage: " + newDamage + " - " + lastDamage); // We must subtract previous damage from new weapon damage for this attack newDamage -= lastDamage; debug("Last damage " + lastDamage + " new damage: " + newLastDamage + " applied: " + newDamage + " ticks: " + livingDamagee.getNoDamageTicks() + " /" + livingDamagee.getMaximumNoDamageTicks() ); } // Update the last damage done, including when it was overdamage. // This means attacks must keep increasing in value during immunity period to keep dealing overdamage. lastDamages.put(livingDamagee.getUniqueId(), newLastDamage); touchExpiry(livingDamagee); return newDamage; } private Double resolveStoredDamage(LivingEntity damagee) { final UUID uuid = damagee.getUniqueId(); final Long expiresAtTick = lastDamageExpiryTicks.get(uuid); if (expiresAtTick != null && expiresAtTick <= tickCounter) { lastDamageExpiryTicks.remove(uuid); lastDamages.remove(uuid); return null; } return lastDamages.get(uuid); } private void clearStoredDamage(LivingEntity damagee) { final UUID uuid = damagee.getUniqueId(); lastDamageExpiryTicks.remove(uuid); lastDamages.remove(uuid); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/MobDamage.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import com.google.common.collect.ImmutableMap; import com.cryptomorin.xseries.XEnchantment; import org.bukkit.enchantments.Enchantment; import org.bukkit.entity.EntityType; import org.bukkit.inventory.ItemStack; import java.util.Map; public class MobDamage { private static final Map enchants; private static final Enchantment SMITE = XEnchantment.SMITE.getEnchant(); private static final Enchantment BANE_OF_ARTHROPODS = XEnchantment.BANE_OF_ARTHROPODS.getEnchant(); static { Map allMobs = ImmutableMap.builder() // Undead (https://minecraft.gamepedia.com/Undead) .put("SKELETON", SMITE) .put("ZOMBIE", SMITE) .put("WITHER", SMITE) .put("WITHER_SKELETON", SMITE) .put("ZOMBIFIED_PIGLIN", SMITE) .put("SKELETON_HORSE", SMITE) .put("STRAY", SMITE) .put("HUSK", SMITE) .put("PHANTOM", SMITE) .put("DROWNED", SMITE) .put("ZOGLIN", SMITE) .put("ZOMBIE_HORSE", SMITE) .put("ZOMBIE_VILLAGER", SMITE) // Arthropods (https://minecraft.gamepedia.com/Arthropod) .put("SPIDER", BANE_OF_ARTHROPODS) .put("CAVE_SPIDER", BANE_OF_ARTHROPODS) .put("BEE", BANE_OF_ARTHROPODS) .put("SILVERFISH", BANE_OF_ARTHROPODS) .put("ENDERMITE", BANE_OF_ARTHROPODS) .build(); ImmutableMap.Builder enchantsBuilder = ImmutableMap.builder(); // Add these individually because some may not exist in the Minecraft version we're running allMobs.keySet().forEach(entityName -> { try { final EntityType entityType = EntityType.valueOf(entityName); final Enchantment enchantment = allMobs.get(entityName); enchantsBuilder.put(entityType, enchantment); } catch (IllegalArgumentException ignored) { } // Mob not supported in this MC version }); enchants = enchantsBuilder.build(); } /** * Gets damage due to Smite and Bane of Arthropods enchantments, when applicable * * @param entity The type of entity that was attacked * @param item The enchanted weapon used in the attack * @return The damage due to the enchantments */ public static double getEntityEnchantmentsDamage(EntityType entity, ItemStack item) { final Enchantment enchantment = enchants.get(entity); if (enchantment == null || enchantment != SMITE || enchantment != BANE_OF_ARTHROPODS) return 0; return 2.5 * item.getEnchantmentLevel(enchantment); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/NewWeaponDamage.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import org.bukkit.Material; /** * Default 1.9 Minecraft tool damage values */ public enum NewWeaponDamage { // common values STONE_SWORD(5), STONE_SHOVEL(3.5F), STONE_PICKAXE(3), STONE_AXE(9), STONE_HOE(1), IRON_SWORD(6), IRON_SHOVEL(4.5F), IRON_PICKAXE(4), IRON_AXE(9), IRON_HOE(1), DIAMOND_SWORD(7), DIAMOND_SHOVEL(5.5F), DIAMOND_PICKAXE(5), DIAMOND_AXE(9), DIAMOND_HOE(1), // pre-1.13 values STONE_SPADE(3.5F), IRON_SPADE(4.5F), DIAMOND_SPADE(5.5F), WOOD_SWORD(4), WOOD_SPADE(2.5F), WOOD_PICKAXE(2), WOOD_AXE(7), WOOD_HOE(1), GOLD_SWORD(4), GOLD_SPADE(2.5F), GOLD_PICKAXE(2), GOLD_AXE(7), GOLD_HOE(1), // post-1.13 values WOODEN_SWORD(4), WOODEN_SHOVEL(2.5F), WOODEN_PICKAXE(2), WOODEN_AXE(7), WOODEN_HOE(1), GOLDEN_SWORD(4), GOLDEN_SHOVEL(2.5F), GOLDEN_PICKAXE(2), GOLDEN_AXE(7), GOLDEN_HOE(1), COPPER_SWORD(5), COPPER_SHOVEL(3.5F), COPPER_PICKAXE(3), COPPER_AXE(9), COPPER_HOE(1), NETHERITE_SWORD(8), NETHERITE_SHOVEL(6.5F), NETHERITE_PICKAXE(6), NETHERITE_AXE(10), NETHERITE_HOE(1), // Weapons introduced after 1.13 TRIDENT(8), // vanilla thrown + melee base (before impaling) MACE(6); // vanilla base damage; fall bonus is added separately in NMS private final float damage; NewWeaponDamage(float damage) { this.damage = damage; } public static float getDamage(String mat) { return valueOf(mat).damage; } public static float getDamage(Material mat) { return getDamage(mat.toString()); } public static Float getDamageOrNull(String mat) { try { return valueOf(mat).damage; } catch (IllegalArgumentException ex) { return null; } } public static Float getDamageOrNull(Material mat) { return getDamageOrNull(mat.toString()); } public float getDamage() { return damage; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/OCMEntityDamageByEntityEvent.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import com.cryptomorin.xseries.XEnchantment; import com.cryptomorin.xseries.XPotion; import kernitus.plugin.OldCombatMechanics.utilities.potions.PotionEffects; import kernitus.plugin.OldCombatMechanics.utilities.potions.WeaknessCompensation; import org.bukkit.Material; import org.bukkit.entity.*; import org.bukkit.event.Cancellable; import org.bukkit.event.Event; import org.bukkit.event.HandlerList; import org.bukkit.event.entity.EntityDamageEvent.DamageCause; import org.bukkit.inventory.ItemStack; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import org.bukkit.NamespacedKey; import org.bukkit.enchantments.Enchantment; import java.util.HashSet; import java.util.Optional; import java.util.Set; import static kernitus.plugin.OldCombatMechanics.utilities.Messenger.debug; public class OCMEntityDamageByEntityEvent extends Event implements Cancellable { private boolean cancelled; private static final HandlerList handlers = new HandlerList(); @Override public HandlerList getHandlers() { return handlers; } public static HandlerList getHandlerList() { return handlers; } private final Entity damager, damagee; private final DamageCause cause; private double rawDamage; private ItemStack weapon; private int sharpnessLevel; private boolean hasWeakness; // The levels as shown in-game, i.e. 1 or 2 corresponding to I and II private int strengthLevel, weaknessLevel; private double baseDamage = 0, mobEnchantmentsDamage = 0, sharpnessDamage = 0, criticalMultiplier = 1; private double strengthModifier = 0, weaknessModifier = 0; // In 1.9 strength modifier is an addend, in 1.8 it is a multiplier and addend (+130%) private boolean isStrengthModifierMultiplier = false; private boolean isStrengthModifierAddend = true; private boolean isWeaknessModifierMultiplier = false; private boolean was1_8Crit = false; private boolean wasSprinting = false; private static final Set warnedUnknownWeaponEnchants = new HashSet<>(); private static final Set VANILLA_ENCHANTMENTS = initVanillaEnchantments(); // Here we reverse-engineer all the various damages caused by removing them one at a time, backwards from what NMS code does. // This is so the modules can listen to this event and make their modifications, then EntityDamageByEntityListener sets the new values back. // Performs the opposite of the following: // (Base + Potion effects, scaled by attack delay) + Critical Hit + (Enchantments, scaled by attack delay), Overdamage, Armour public OCMEntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, double rawDamage) { this.damager = damager; this.damagee = damagee; this.cause = cause; // We ignore attacks like arrows etc. because we do not need to change the attack side of those // Other modules such as old armour strength work independently of this event if (!(damager instanceof LivingEntity)) { setCancelled(true); return; } // The raw damage passed to this event is EDBE's BASE damage, which does not include armour effects or resistance etc (defence) this.rawDamage = rawDamage; /* Invulnerability will cause less damage if they attack with a stronger weapon while vulnerable. We must detect this and account for it, instead of setting the usual base weapon damage. We artificially set the last damage to 0 between events so that all hits will register, however we only do this for DamageByEntity, so there could still be environmental damage (e.g. cactus). */ if (damagee instanceof LivingEntity) { final LivingEntity livingDamagee = (LivingEntity) damagee; if ((float) livingDamagee.getNoDamageTicks() > (float) livingDamagee.getMaximumNoDamageTicks() / 2.0F) { // NMS code also checks if current damage is higher that previous damage. However, here the event // already has the difference between the two as the raw damage, and the event does not fire at all // if this precondition is not met. // Adjust for last damage being environmental sources (e.g. cactus, fall damage) final double lastDamage = livingDamagee.getLastDamage(); this.rawDamage = rawDamage + lastDamage; debug(livingDamagee, "Overdamaged!: " + livingDamagee.getNoDamageTicks() + "/" + livingDamagee.getMaximumNoDamageTicks() + " last: " + livingDamagee.getLastDamage()); } else { debug(livingDamagee, "Invulnerability: " + livingDamagee.getNoDamageTicks() + "/" + livingDamagee.getMaximumNoDamageTicks() + " last: " + livingDamagee.getLastDamage()); } } final LivingEntity livingDamager = (LivingEntity) damager; weapon = livingDamager.getEquipment().getItemInMainHand(); // Yay paper. Why do you need to return null here? if (weapon == null) weapon = new ItemStack(Material.AIR); // Technically the weapon could be in the offhand, i.e. a bow. // However, we are only concerned with melee weapons here, which will always be in the main hand. final EntityType damageeType = damagee.getType(); warnOnUnknownWeaponEnchantments(weapon); debug(livingDamager, "Raw attack damage: " + rawDamage); debug(livingDamager, "Without overdamage: " + this.rawDamage); mobEnchantmentsDamage = MobDamage.getEntityEnchantmentsDamage(damageeType, weapon); sharpnessLevel = weapon.getEnchantmentLevel(XEnchantment.SHARPNESS.getEnchant()); sharpnessDamage = DamageUtils.getNewSharpnessDamage(sharpnessLevel); // Scale enchantment damage by attack cooldown if (damager instanceof HumanEntity) { final float cooldown = DamageUtils.getAttackCooldown.apply((HumanEntity) damager, 0.5F); mobEnchantmentsDamage *= cooldown; sharpnessDamage *= cooldown; } debug(livingDamager, "Mob: " + mobEnchantmentsDamage + " Sharpness: " + sharpnessDamage); // Amount of damage including potion effects and critical hits double tempDamage = this.rawDamage - mobEnchantmentsDamage - sharpnessDamage; debug(livingDamager, "No ench damage: " + tempDamage); // Check if it's a critical hit if (livingDamager instanceof Player && DamageUtils.isCriticalHit1_8((HumanEntity) livingDamager)){ was1_8Crit = true; debug(livingDamager, "1.8 Critical hit detected"); // In 1.9 a crit also requires the player not to be sprinting if (DamageUtils.isCriticalHit1_9((Player) livingDamager)) { debug(livingDamager, "1.9 Critical hit detected"); debug("1.9 Critical hit detected"); criticalMultiplier = 1.5; tempDamage /= 1.5; } } // Un-scale the damage by the attack strength if (damager instanceof HumanEntity) { final float cooldown = DamageUtils.getAttackCooldown.apply((HumanEntity) damager, 0.5F); tempDamage /= 0.2F + cooldown * cooldown * 0.8F; } // amplifier 0 = Strength I amplifier 1 = Strength II strengthLevel = PotionEffects.get(livingDamager, XPotion.STRENGTH.get()) .map(PotionEffect::getAmplifier) .orElse(-1) + 1; // Store per-level modifier so listeners can multiply by level consistently. strengthModifier = strengthLevel > 0 ? 3 : 0; debug(livingDamager, "Strength Modifier: " + strengthModifier); // Don't set has weakness if amplifier is < -1, which is outside normal range and probably set by a plugin // We use an amplifier of -1 (Level 0) to have no effect so weaker attacks will register // Any positive amplifier is treated as "weakness present" for old-combat behaviour final Optional weaknessAmplifier = PotionEffects.get(livingDamager, PotionEffectType.WEAKNESS) .map(PotionEffect::getAmplifier); final int weaknessValue = weaknessAmplifier.orElse(-1); if (weaknessAmplifier.isPresent() && weaknessValue >= -1) { hasWeakness = true; final int rawWeaknessLevel = weaknessValue + 1; weaknessLevel = Math.min(rawWeaknessLevel, 1); } else { hasWeakness = false; weaknessLevel = 0; } weaknessModifier = weaknessLevel * -4; debug(livingDamager, "Weakness Modifier: " + weaknessModifier); final boolean weaknessCompensated = WeaknessCompensation.hasModifier(livingDamager); final double weaknessForBase = weaknessCompensated ? 0 : weaknessModifier; if (weaknessCompensated) { debug(livingDamager, "Weakness compensated; skipping base weakness modifier"); } baseDamage = tempDamage + weaknessForBase - (strengthModifier * strengthLevel); debug(livingDamager, "Base tool damage: " + baseDamage); } private static void warnOnUnknownWeaponEnchantments(ItemStack weapon) { if (weapon == null || weapon.getEnchantments().isEmpty()) { return; } final Enchantment sharpness = XEnchantment.SHARPNESS.getEnchant(); final Enchantment smite = XEnchantment.SMITE.getEnchant(); final Enchantment bane = XEnchantment.BANE_OF_ARTHROPODS.getEnchant(); for (Enchantment enchantment : weapon.getEnchantments().keySet()) { if (enchantment == null || enchantment.equals(sharpness) || enchantment.equals(smite) || enchantment.equals(bane)) { continue; } if (!shouldWarnOnUnknownEnchantment(enchantment)) { continue; } final String name = enchantment.getName(); if (warnedUnknownWeaponEnchants.add(name)) { kernitus.plugin.OldCombatMechanics.utilities.Messenger.warn( "Weapon enchantment '%s' is not modelled by OCM damage calculations; results may differ", name); } } } private static boolean shouldWarnOnUnknownEnchantment(Enchantment enchantment) { try { final NamespacedKey key = enchantment.getKey(); if (key != null) { return !"minecraft".equals(key.getNamespace()); } } catch (NoSuchMethodError | NoClassDefFoundError ignored) { // Legacy servers do not expose NamespacedKey; fall back to known vanilla list. } return !isVanillaEnchantment(enchantment); } private static Set initVanillaEnchantments() { final Set enchantments = new HashSet<>(); for (XEnchantment xEnchantment : XEnchantment.values()) { final Enchantment enchantment = xEnchantment.getEnchant(); if (enchantment != null) { enchantments.add(enchantment); } } return enchantments; } private static boolean isVanillaEnchantment(Enchantment enchantment) { return VANILLA_ENCHANTMENTS.contains(enchantment); } public Entity getDamager() { return damager; } public Entity getDamagee() { return damagee; } public DamageCause getCause() { return cause; } public double getRawDamage() { return rawDamage; } public ItemStack getWeapon() { return weapon; } public int getSharpnessLevel() { return sharpnessLevel; } public double getStrengthModifier() { return strengthModifier; } public void setStrengthModifier(double strengthModifier) { this.strengthModifier = strengthModifier; } public int getStrengthLevel() { return strengthLevel; } /** * Whether the attacker had the weakness potion effect, * and the level of the effect was either 0 (used by OCM) or 1 (normal value). * Values outside this range are to be ignored, as they are probably from other plugins. */ public boolean hasWeakness() { return hasWeakness; } public int getWeaknessLevel() { return weaknessLevel; } public double getWeaknessModifier() { return weaknessModifier; } public void setWeaknessModifier(double weaknessModifier) { this.weaknessModifier = weaknessModifier; } public void setWeaknessLevel(int weaknessLevel) { this.weaknessLevel = weaknessLevel; } public boolean isStrengthModifierMultiplier() { return isStrengthModifierMultiplier; } public void setIsStrengthModifierMultiplier(boolean isStrengthModifierMultiplier) { this.isStrengthModifierMultiplier = isStrengthModifierMultiplier; } public void setIsStrengthModifierAddend(boolean isStrengthModifierAddend) { this.isStrengthModifierAddend = isStrengthModifierAddend; } public boolean isWeaknessModifierMultiplier() { return isWeaknessModifierMultiplier; } public void setIsWeaknessModifierMultiplier(boolean weaknessModifierMultiplier) { isWeaknessModifierMultiplier = weaknessModifierMultiplier; } public boolean isStrengthModifierAddend() { return isStrengthModifierAddend; } public double getBaseDamage() { return baseDamage; } public void setBaseDamage(double baseDamage) { this.baseDamage = baseDamage; } public double getMobEnchantmentsDamage() { return mobEnchantmentsDamage; } public void setMobEnchantmentsDamage(double mobEnchantmentsDamage) { this.mobEnchantmentsDamage = mobEnchantmentsDamage; } public double getSharpnessDamage() { return sharpnessDamage; } public void setSharpnessDamage(double sharpnessDamage) { this.sharpnessDamage = sharpnessDamage; } public double getCriticalMultiplier() { return criticalMultiplier; } public void setCriticalMultiplier(double criticalMultiplier) { this.criticalMultiplier = criticalMultiplier; } @Override public boolean isCancelled() { return cancelled; } @Override public void setCancelled(boolean cancelled) { this.cancelled = cancelled; } public boolean wasSprinting() { return wasSprinting; } public void setWasSprinting(boolean wasSprinting) { this.wasSprinting = wasSprinting; } public boolean was1_8Crit() { return was1_8Crit; } public void setWas1_8Crit(boolean was1_8Crit) { this.was1_8Crit = was1_8Crit; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/damage/WeaponDamages.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.damage; import com.cryptomorin.xseries.XMaterial; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.utilities.ConfigUtils; import org.bukkit.Material; import org.bukkit.configuration.ConfigurationSection; import java.util.HashMap; import java.util.Map; public class WeaponDamages { private static Map damages; private static OCMMain plugin; public static void initialise(OCMMain plugin) { WeaponDamages.plugin = plugin; reload(); } private static void reload() { final ConfigurationSection section = plugin.getConfig().getConfigurationSection("old-tool-damage.damages"); damages = ConfigUtils.loadDoubleMap(section); } public static double getDamage(Material mat) { final String name = mat.name().replace("GOLDEN", "GOLD").replace("WOODEN", "WOOD").replace("SHOVEL", "SPADE"); return damages.getOrDefault(name, -1.0); } public static double getDamage(String key) { return damages.getOrDefault(key, -1.0); } public static Map getMaterialDamages() { final Map materialMap = new HashMap<>(); damages.forEach((name, damage) -> { final String newName = name.replace("GOLD", "GOLDEN").replace("WOOD", "WOODEN").replace("SPADE", "SHOVEL"); XMaterial.matchXMaterial(newName).ifPresent(xmaterial -> { final Material material = xmaterial.parseMaterial(); if (material != null) { materialMap.put(material, damage); } }); }); return materialMap; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/potions/PotionDurations.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.potions; /** * Hold information on duration of drinkable & splash version of a potion type */ public final class PotionDurations { private final int drinkable; private final int splash; public PotionDurations(int drinkable, int splash) { this.drinkable = drinkable; this.splash = splash; } public int drinkable() { return drinkable; } public int splash() { return splash; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/potions/PotionEffects.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.potions; import kernitus.plugin.OldCombatMechanics.utilities.reflection.SpigotFunctionChooser; import org.bukkit.entity.LivingEntity; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import java.util.Optional; public class PotionEffects { private static final SpigotFunctionChooser getPotionEffectsFunction = SpigotFunctionChooser.apiCompatCall((le, type) -> le.getPotionEffect(type), (le, type) -> le.getActivePotionEffects().stream() .filter(potionEffect -> potionEffect.getType().equals(type)) .findAny() .orElse(null) ); /** * Returns the {@link PotionEffect} of a given {@link PotionEffectType} for a given {@link LivingEntity}, if present. * * @param entity the entity to query * @param type the type to search * @return the {@link PotionEffect} if present */ public static Optional get(LivingEntity entity, PotionEffectType type) { return Optional.ofNullable(getOrNull(entity, type)); } /** * Returns the {@link PotionEffect} of a given {@link PotionEffectType} for a given {@link LivingEntity}, if present. * * @param entity the entity to query * @param type the type to search * @return the {@link PotionEffect} or null if not present */ public static PotionEffect getOrNull(LivingEntity entity, PotionEffectType type) { return getPotionEffectsFunction.apply(entity, type); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/potions/PotionKey.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.potions; import com.cryptomorin.xseries.XPotion; import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.potion.PotionData; import org.bukkit.potion.PotionType; import java.util.Locale; import java.util.Objects; import java.util.Optional; /** * Key for potion duration configuration, based on effect and strength/length flags. */ public final class PotionKey { private static final String STRONG_PREFIX = "STRONG_"; private static final String LONG_PREFIX = "LONG_"; private final XPotion potion; private final boolean strong; private final boolean extended; private PotionKey(XPotion potion, boolean strong, boolean extended) { this.potion = Objects.requireNonNull(potion, "potion"); this.strong = strong; this.extended = extended; } public XPotion getPotion() { return potion; } public boolean isStrong() { return strong; } public boolean isExtended() { return extended; } public boolean isPotion(XPotion target) { return potion == target; } public String getDebugName() { if (strong) { return STRONG_PREFIX + potion.name(); } if (extended) { return LONG_PREFIX + potion.name(); } return potion.name(); } public static Optional fromConfigKey(String key) { if (key == null) { return Optional.empty(); } String name = key.toUpperCase(Locale.ROOT); boolean strong = false; boolean extended = false; if (name.startsWith(STRONG_PREFIX)) { strong = true; name = name.substring(STRONG_PREFIX.length()); } else if (name.startsWith(LONG_PREFIX)) { extended = true; name = name.substring(LONG_PREFIX.length()); } return fromBaseName(name, strong, extended); } public static Optional fromPotionMeta(PotionMeta potionMeta) { if (potionMeta == null) { return Optional.empty(); } try { PotionType potionType = potionMeta.getBasePotionType(); if (potionType == null) { return Optional.empty(); } return fromPotionTypeName(potionType.name(), false, false); } catch (NoSuchMethodError e) { PotionData potionData = potionMeta.getBasePotionData(); return fromPotionTypeName(potionData.getType().name(), potionData.isUpgraded(), potionData.isExtended()); } } private static Optional fromPotionTypeName(String name, boolean upgraded, boolean extended) { String baseName = name.toUpperCase(Locale.ROOT); boolean strong = upgraded; boolean longDuration = extended; if (baseName.startsWith(STRONG_PREFIX)) { strong = true; baseName = baseName.substring(STRONG_PREFIX.length()); } else if (baseName.startsWith(LONG_PREFIX)) { longDuration = true; baseName = baseName.substring(LONG_PREFIX.length()); } return fromBaseName(baseName, strong, longDuration); } private static Optional fromBaseName(String baseName, boolean strong, boolean extended) { Optional potion = XPotion.matchXPotion(baseName); if (!potion.isPresent()) { return Optional.empty(); } XPotion found = potion.get(); if (found == XPotion.INSTANT_DAMAGE || found == XPotion.INSTANT_HEALTH) { return Optional.empty(); } return Optional.of(new PotionKey(found, strong, extended)); } @Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof PotionKey)) { return false; } PotionKey that = (PotionKey) other; return strong == that.strong && extended == that.extended && potion == that.potion; } @Override public int hashCode() { return Objects.hash(potion, strong, extended); } @Override public String toString() { return "PotionKey{" + getDebugName() + "}"; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/potions/WeaknessCompensation.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.potions; import com.cryptomorin.xseries.XAttribute; import org.bukkit.attribute.Attribute; import org.bukkit.attribute.AttributeInstance; import org.bukkit.attribute.AttributeModifier; import org.bukkit.entity.LivingEntity; import java.util.UUID; public final class WeaknessCompensation { public static final UUID MODIFIER_UUID = UUID.fromString("5cf9f56c-7b95-4d39-9e1f-7c0b4c84f26c"); private static final String MODIFIER_NAME = "OCM-Weakness-Compensation"; private static final double MODIFIER_AMOUNT = 4.0; private WeaknessCompensation() { } public static boolean hasModifier(LivingEntity entity) { final AttributeInstance attribute = getAttackDamageAttribute(entity); if (attribute == null) return false; for (AttributeModifier modifier : attribute.getModifiers()) { if (MODIFIER_UUID.equals(modifier.getUniqueId())) return true; } return false; } public static void apply(LivingEntity entity) { final AttributeInstance attribute = getAttackDamageAttribute(entity); if (attribute == null || hasModifier(entity)) return; final AttributeModifier modifier = new AttributeModifier( MODIFIER_UUID, MODIFIER_NAME, MODIFIER_AMOUNT, AttributeModifier.Operation.ADD_NUMBER ); attribute.addModifier(modifier); } public static void remove(LivingEntity entity) { final AttributeInstance attribute = getAttackDamageAttribute(entity); if (attribute == null) return; for (AttributeModifier modifier : attribute.getModifiers()) { if (MODIFIER_UUID.equals(modifier.getUniqueId())) { attribute.removeModifier(modifier); } } } private static AttributeInstance getAttackDamageAttribute(LivingEntity entity) { final Attribute attribute = XAttribute.ATTACK_DAMAGE.get(); if (attribute == null) return null; return entity.getAttribute(attribute); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/reflection/Reflector.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.reflection; import org.bukkit.Bukkit; import java.lang.reflect.*; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.function.BiFunction; import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; public class Reflector { private static String version; private static int majorVersion, minorVersion, patchVersion; static { try { // Split on the "-" to just get the version information version = Bukkit.getServer().getBukkitVersion().split("-")[0]; final String[] splitVersion = version.split("\\."); majorVersion = Integer.parseInt(splitVersion[0]); minorVersion = Integer.parseInt(splitVersion[1]); if(splitVersion.length > 2) { patchVersion = Integer.parseInt(splitVersion[2]); } else { patchVersion = 0; } } catch (Exception e) { System.err.println("Failed to load Reflector: " + e.getMessage()); } } public static String getVersion() { return version; } /** * Checks if the current server version is newer or equal to the one provided. * * @param major the target major version * @param minor the target minor version. 0 for all * @param patch the target patch version. 0 for all * @return true if the server version is newer or equal to the one provided */ public static boolean versionIsNewerOrEqualTo(int major, int minor, int patch) { if (getMajorVersion() < major) return false; if (getMinorVersion() < minor) return false; return getPatchVersion() >= patch; } private static int getMajorVersion() { return majorVersion; } private static int getMinorVersion() { return minorVersion; } private static int getPatchVersion() { return patchVersion; } public static Class getClass(String fqn) { try { return Class.forName(fqn); } catch (ClassNotFoundException e) { throw new RuntimeException("Couldn't load class " + fqn, e); } } public static Method getMethod(Class clazz, String name) { return Stream.concat( Arrays.stream(clazz.getDeclaredMethods()), Arrays.stream(clazz.getMethods()) ) .filter(method -> method.getName().equals(name)) .peek(method -> method.setAccessible(true)) .findFirst() .orElse(null); } public static Method getMethod(Class clazz, String name, int parameterCount) { return Stream.concat( Arrays.stream(clazz.getDeclaredMethods()), Arrays.stream(clazz.getMethods()) ) .filter(method -> method.getName().equals(name) && method.getParameterCount() == parameterCount) .peek(method -> method.setAccessible(true)) .findFirst() .orElse(null); } public static Method getMethod(Class clazz, Class returnType, String... parameterTypeSimpleNames){ List typeNames = Arrays.asList(parameterTypeSimpleNames); return Stream.concat( Arrays.stream(clazz.getDeclaredMethods()), Arrays.stream(clazz.getMethods()) ) .filter(method -> method.getReturnType() == returnType) .filter(it -> getParameterNames.apply(it).equals(typeNames)) .peek(method -> method.setAccessible(true)) .findFirst() .orElse(null); } private static final Function> getParameterNames = method -> Arrays .stream(method.getParameters()) .map(Parameter::getType) .map(Class::getSimpleName) .collect(Collectors.toList()); public static Method getMethod(Class clazz, String name, String... parameterTypeSimpleNames) { List typeNames = Arrays.asList(parameterTypeSimpleNames); return Stream.concat( Arrays.stream(clazz.getDeclaredMethods()), Arrays.stream(clazz.getMethods()) ) .filter(it -> it.getName().equals(name)) .filter(it -> getParameterNames.apply(it).equals(typeNames)) .peek(it -> it.setAccessible(true)) .findFirst() .orElse(null); } /** * Finds a method by name where the provided parameter types are assignable to the method parameters. * Null entries in {@code parameterTypes} act as wildcards. */ public static Method getMethodAssignable(Class clazz, String name, Class... parameterTypes) { return Stream.concat( Arrays.stream(clazz.getDeclaredMethods()), Arrays.stream(clazz.getMethods()) ) .filter(it -> it.getName().equals(name)) .filter(it -> it.getParameterCount() == parameterTypes.length) .filter(it -> areParametersAssignable(it.getParameterTypes(), parameterTypes)) .peek(it -> it.setAccessible(true)) .findFirst() .orElse(null); } public static Method getMethodByGenericReturnType(TypeVariable typeVar, Class clazz){ for (Method method : clazz.getMethods()){ if (method.getGenericReturnType().getTypeName().equals(typeVar.getName())){ return method; } } throw new RuntimeException("Method with type " + typeVar + " not found"); } public static T invokeMethod(Method method, Object handle, Object... params) { try { @SuppressWarnings("unchecked") T t = (T) method.invoke(handle, params); return t; } catch (IllegalAccessException | InvocationTargetException e) { throw new RuntimeException(e); } } /** * Resolves the given method, caches it and then uses that instance for all future invocations. *

* The returned function just invokes the cached method for a given target. * * @param clazz the clazz the method is in * @param name the name of the method * @param the type of the handle * @param the type of the parameter(s) * @param the type of the method result * @return a function that invokes the retrieved cached method for its argument */ public static BiFunction memoiseMethodInvocation(Class clazz, String name, String... argTypes) { final Method method = getMethod(clazz, name, argTypes); return (t, u) -> { // If they did not want to send any arguments, should be zero-length array // This check is necessary cause of varargs, otherwise we get 1 length array of 0-length array if(u instanceof Object[] && ((Object[]) u).length == 0) return invokeMethod(method, t); return invokeMethod(method, t, u); }; } public static Field getField(Class clazz, String fieldName) { try { Field field = clazz.getDeclaredField(fieldName); field.setAccessible(true); return field; } catch (NoSuchFieldException e) { throw new RuntimeException(e); } } public static Field getFieldByType(Class clazz, String simpleClassName) { for (Field declaredField : clazz.getDeclaredFields()) { if (declaredField.getType().getSimpleName().equals(simpleClassName)) { declaredField.setAccessible(true); return declaredField; } } throw new RuntimeException("Field with type " + simpleClassName + " not found"); } public static Field getMapFieldWithTypes(Class clazz, Class keyType, Class valueType) { for (Field field : clazz.getDeclaredFields()) { // Check if the field is a Map if (Map.class.isAssignableFrom(field.getType())) { // Get the generic type of the field final Type genericType = field.getGenericType(); if (genericType instanceof ParameterizedType) { final ParameterizedType parameterizedType = (ParameterizedType) genericType; final Type[] actualTypeArguments = parameterizedType.getActualTypeArguments(); // Check if the map's key and value types match the specified classes if (actualTypeArguments.length == 2 && actualTypeArguments[0].equals(keyType) && actualTypeArguments[1].equals(valueType)) { field.setAccessible(true); return field; } } } } throw new RuntimeException("Map field with key type " + keyType.getSimpleName() + " and value type " + valueType.getSimpleName() + " not found"); } public static Object getFieldValueByType(Object object, String simpleClassName) throws Exception { Stream publicFields = Stream.of(object.getClass().getFields()); Stream declaredFields = Stream.of(object.getClass().getDeclaredFields()); Stream allFields = Stream.concat(publicFields, declaredFields); // Find the first field that matches the type name Field matchingField = allFields .filter(declaredField -> declaredField.getType().getSimpleName().equals(simpleClassName)) .findFirst() .orElseThrow(() -> new NoSuchFieldException("Couldn't find field with type " + simpleClassName + " in " + object.getClass())); // Make the field accessible and return its value matchingField.setAccessible(true); return matchingField.get(object); } public static Object getFieldValue(Field field, Object handle) { field.setAccessible(true); try { return field.get(handle); } catch (IllegalAccessException e) { throw new RuntimeException(e); } } public static void setFieldValue(Field field, Object handle, Object value) { field.setAccessible(true); try { field.set(handle, value); } catch (IllegalAccessException e) { throw new RuntimeException(e); } } public static Constructor getConstructor(Class clazz, int numParams) { return Stream.concat( Arrays.stream(clazz.getDeclaredConstructors()), Arrays.stream(clazz.getConstructors()) ) .filter(constructor -> constructor.getParameterCount() == numParams) .peek(it -> it.setAccessible(true)) .findFirst() .orElse(null); } public static Constructor getConstructor(Class clazz, String... parameterTypeSimpleNames) { Function, List> getParameterNames = constructor -> Arrays .stream(constructor.getParameters()) .map(Parameter::getType) .map(Class::getSimpleName) .collect(Collectors.toList()); List typeNames = Arrays.asList(parameterTypeSimpleNames); return Stream.concat( Arrays.stream(clazz.getDeclaredConstructors()), Arrays.stream(clazz.getConstructors()) ) .filter(constructor -> getParameterNames.apply(constructor).equals(typeNames)) .peek(it -> it.setAccessible(true)) .findFirst() .orElse(null); } /** * Finds a constructor where the provided parameter types are assignable to the constructor parameters. * Null entries in {@code parameterTypes} act as wildcards. */ public static Constructor getConstructorAssignable(Class clazz, Class... parameterTypes) { return Stream.concat( Arrays.stream(clazz.getDeclaredConstructors()), Arrays.stream(clazz.getConstructors()) ) .filter(constructor -> constructor.getParameterCount() == parameterTypes.length) .filter(constructor -> areParametersAssignable(constructor.getParameterTypes(), parameterTypes)) .peek(it -> it.setAccessible(true)) .findFirst() .orElse(null); } /** * Attempts to resolve an enum constant by name, trying each provided name in order. */ public static Object getEnumConstant(Class enumClass, String... names) { if (!enumClass.isEnum()) { throw new IllegalArgumentException(enumClass.getName() + " is not an enum"); } @SuppressWarnings("unchecked") Class typedEnum = (Class) enumClass; for (String name : names) { if (name == null) continue; try { return Enum.valueOf(typedEnum, name); } catch (IllegalArgumentException ignored) { // try next } for (Object constant : enumClass.getEnumConstants()) { Enum enumConstant = (Enum) constant; if (enumConstant.name().equalsIgnoreCase(name) || enumConstant.toString().equals(name)) { return enumConstant; } } } throw new IllegalArgumentException("No enum constant found in " + enumClass.getName()); } private static boolean areParametersAssignable(Class[] target, Class[] provided) { if (target.length != provided.length) return false; for (int i = 0; i < target.length; i++) { Class providedType = provided[i]; if (providedType == null) continue; if (!target[i].isAssignableFrom(providedType)) return false; } return true; } /** * Checks if a given class somehow inherits from another class * * @param toCheck The class to check * @param inheritedClass The inherited class, it should have * @return True if {@code toCheck} somehow inherits from * {@code inheritedClass} */ public static boolean inheritsFrom(Class toCheck, Class inheritedClass) { if (inheritedClass.isAssignableFrom(toCheck)) { return true; } for (Class implementedInterface : toCheck.getInterfaces()) { if (inheritsFrom(implementedInterface, inheritedClass)) { return true; } } return false; } public static T getUnchecked(UncheckedReflectionSupplier supplier) { try { return supplier.get(); } catch (ReflectiveOperationException e) { throw new RuntimeException(e); } } public static void doUnchecked(UncheckedReflectionRunnable runnable) { try { runnable.run(); } catch (ReflectiveOperationException e) { throw new RuntimeException(e); } } public interface UncheckedReflectionSupplier { T get() throws ReflectiveOperationException; } public interface UncheckedReflectionRunnable { void run() throws ReflectiveOperationException; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/reflection/SpigotFunctionChooser.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.reflection; import java.util.function.BiFunction; /** * Chooses a Spigot API function to use * Chooses a function to apply based on a test supplier, remembers the choice * and only uses the corresponding * function in the future. *

* The branch to pick is determined during the first execution of its * {@link #apply(Object, Object)} method!. * This means that no matter how often the feature branch is invoked, it will * never reconsider its choice. * * @param the type of the entity to apply the function to * @param the type of the extra parameter(s). Use {@link Object} if unused, * or list of objects if multiple. * @param the return type of the function */ public class SpigotFunctionChooser { private final BiFunction test; private final BiFunction trueBranch; private final BiFunction falseBranch; private BiFunction chosen; /** * Creates a new {@link SpigotFunctionChooser}, which chooses between two given * functions. * * @param test the test supplier that will be invoked to choose a branch * @param trueBranch the branch to pick when then test is true * @param falseBranch the branch to pick when then test is false */ public SpigotFunctionChooser(BiFunction test, BiFunction trueBranch, BiFunction falseBranch) { this.test = test; this.trueBranch = trueBranch; this.falseBranch = falseBranch; } /** * Applies the stored action to the given target and chooses what branch to use * on the first call. * * @param target the target to apply it to * @param parameters the extra parameters to pass to the function * @return the result of applying the function to the given target */ public R apply(T target, U parameters) { if (chosen == null) { synchronized (this) { if (chosen == null) { chosen = test.apply(target, parameters) ? trueBranch : falseBranch; } } } return chosen.apply(target, parameters); } /** * Version without extra parameter(s) of {@link #apply(Object, Object)} */ @SuppressWarnings("unchecked") public R apply(T target) { return apply(target, (U) new Object[0]); } /** * Creates a {@link SpigotFunctionChooser} that uses the success parameter when * the action completes without an * exception and otherwise uses the failure parameter. *

* The action is, per the doc for {@link SpigotFunctionChooser} only called * once. * * @param action the action to invoke * @param success the branch to take when no exception occurs * @param failure the branch to take when an exception occurs * @param the type of the class containing the method * @param the type of the parameter(s) * @param the return type of the method * @return a {@link SpigotFunctionChooser} that picks the branch based on * whether action threw an exception */ private static SpigotFunctionChooser onException(ExceptionalFunction action, BiFunction success, BiFunction failure) { return new SpigotFunctionChooser<>( (t, u) -> { try { action.apply(t, u); return true; } catch (ExceptionalFunction.WrappedException e) { final Throwable failureCause = rootCause(e); if (isCompatibilityFailure(failureCause)) { return false; } throw propagate(failureCause); } }, success, failure); } private static Throwable rootCause(Throwable throwable) { Throwable current = throwable; while (current.getCause() != null && current.getCause() != current) { current = current.getCause(); } return current; } private static RuntimeException propagate(Throwable throwable) { if (throwable instanceof RuntimeException) { throw (RuntimeException) throwable; } if (throwable instanceof Error) { throw (Error) throwable; } throw new RuntimeException(throwable); } private static boolean isCompatibilityFailure(Throwable throwable) { if (throwable == null) { return false; } if (throwable instanceof LinkageError) { return true; } if (throwable instanceof NoSuchMethodException || throwable instanceof ClassNotFoundException) { return true; } if (throwable instanceof UnsupportedOperationException) { return isApprovedUnsupportedOperation((UnsupportedOperationException) throwable); } return false; } private static boolean isApprovedUnsupportedOperation(UnsupportedOperationException exception) { final String className = exception.getClass().getSimpleName(); if (className != null && className.toLowerCase().startsWith("compat")) { return true; } final String message = exception.getMessage(); if (message == null) { return false; } final String normalised = message.toLowerCase(); return normalised.matches(".*(^|[^a-z])compat(ibility)?([^a-z]|$).*"); } /** * Calls the Spigot API method if possible, otherwise uses reflection to access * same method. * Useful for API methods that were only added after a certain version. Caches * chosen method for performance. * *

* Note: 1.16 is last version with Spigot-mapped fields, 1.17 with Spigot-mapped * methods. * * @param apiCall A reference to the function that should be called * @param clazz The class containing the function to be accessed via * reflection * @param name The name of the function to be accessed via reflection * @return A new instance of {@link SpigotFunctionChooser} */ public static SpigotFunctionChooser apiCompatReflectionCall(ExceptionalFunction apiCall, Class clazz, String name, String... argTypes) { return onException(apiCall, apiCall, Reflector.memoiseMethodInvocation(clazz, name, argTypes)); } /** * Calls the Spigot API method if possible, otherwise uses the provided function * as a workaround. *

* This should be used to avoid reflection wherever possible, making the plugin * more compatible. * Chosen method is cached for performance. Do not use method references as they * are eagerly-bound in Java 8. *

* * @param apiCall A reference to the function that should be called * @param altFunc A function that should instead be called if API method not * available. * @return A new instance of {@link SpigotFunctionChooser} */ public static SpigotFunctionChooser apiCompatCall(ExceptionalFunction apiCall, BiFunction altFunc) { return onException(apiCall, apiCall, altFunc); } @FunctionalInterface public interface ExceptionalFunction extends BiFunction { // Compatibility policy: API-compat fallbacks must only trigger for missing/binary-incompatible API // failures (for example LinkageError and reflection discovery failures) plus explicit // compatibility-style UnsupportedOperationException signals (for example class names beginning with // "compat" or message tokens "compat"/"compatibility", but not generic wording like // "incompatible"). Ordinary runtime logic failures are // rethrown and must not // silently select the fallback branch. /** * Called by {@link #apply(Object, Object)}, this method is the target of the * functional interface and where you can * write your logic, that might throw an exception. * * @param t the function argument * @return the function result */ R applyWithException(T t, U params) throws Throwable; /** * {@inheritDoc} * * @param t {@inheritDoc} * @return {@inheritDoc} * @throws WrappedException if any *Throwable* is thrown */ @Override default R apply(T t, U u) { try { return applyWithException(t, u); } catch (Throwable e) { throw new WrappedException(e); } } class WrappedException extends RuntimeException { WrappedException(Throwable cause) { super(cause); } } } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/reflection/VersionCompatUtils.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.reflection; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.LivingEntity; import java.lang.reflect.Method; import java.util.Map; import java.util.WeakHashMap; /** * Utilities to help with keeping compatibility across multiple versions of the * game. */ public class VersionCompatUtils { private static Method cooldownMethod; private static final Map, Method> absorptionAmountMethodCache = new WeakHashMap<>(); private static final Map, Method> handleMethodCache = new WeakHashMap<>(); /** * Returns a Craft object from the given Spigot object, e.g. CraftPlayer from * Player. * Useful for accessing properties not available through Spigot's API. * * @param spigotObject The spigot object to get the handle of, e.g. Player * @return The Craft object */ private static Object getCraftHandle(Object spigotObject) { final Class clazz = spigotObject.getClass(); Method handle = handleMethodCache.get(clazz); if (handle == null) { handle = Reflector.getMethod(clazz, "getHandle"); handleMethodCache.put(clazz, handle); } return Reflector.invokeMethod(handle, spigotObject); } public static float getAttackCooldown(HumanEntity he) { final Object craftHumanEntity = getCraftHandle(he); // public float x(float a), grab by return and param type, cause name changes in // each version if (cooldownMethod == null) // cache this to not search for it every single time cooldownMethod = Reflector.getMethod(craftHumanEntity.getClass(), float.class, "float"); return Reflector.invokeMethod(cooldownMethod, craftHumanEntity, 0.5F); } public static float getAbsorptionAmount(LivingEntity livingEntity) { final Object craftLivingEntity = getCraftHandle(livingEntity); final Class leClass = craftLivingEntity.getClass(); final Method absorptionAmountMethod; // Cache method for each subclass of LivingEntity to not search for it every // single time // Cannot cache for LE itself because method is obtained from each subclass if (!absorptionAmountMethodCache.containsKey(leClass)) { absorptionAmountMethod = Reflector.getMethod(craftLivingEntity.getClass(), "getAbsorptionHearts"); absorptionAmountMethodCache.put(leClass, absorptionAmountMethod); } else { absorptionAmountMethod = absorptionAmountMethodCache.get(leClass); } // Give useful debugging information in case the method cannot be applied if (!absorptionAmountMethod.getDeclaringClass().isAssignableFrom(craftLivingEntity.getClass())) { throw new IllegalArgumentException( "Cannot call method '" + absorptionAmountMethod + "' of class '" + absorptionAmountMethod.getDeclaringClass().getName() + "' using object '" + craftLivingEntity + "' of class '" + craftLivingEntity.getClass().getName() + "' because" + " object '" + craftLivingEntity + "' is not an instance of '" + absorptionAmountMethod.getDeclaringClass().getName() + "'"); } return Reflector.invokeMethod(absorptionAmountMethod, craftLivingEntity); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/storage/ModesetListener.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.storage; import kernitus.plugin.OldCombatMechanics.OCMMain; import kernitus.plugin.OldCombatMechanics.module.OCMModule; import kernitus.plugin.OldCombatMechanics.utilities.Config; import kernitus.plugin.OldCombatMechanics.utilities.Messenger; import org.bukkit.World; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.player.PlayerChangedWorldEvent; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.world.WorldLoadEvent; import org.bukkit.event.world.WorldUnloadEvent; import java.util.Set; import java.util.UUID; /** * Listens to players changing world / spawning etc. * and updates modeset accordingly */ public class ModesetListener extends OCMModule { public ModesetListener(OCMMain plugin) { super(plugin, "modeset-listener"); } @EventHandler(priority = EventPriority.LOWEST) public void onPlayerChangedWorld(PlayerChangedWorldEvent event) { final Player player = event.getPlayer(); final UUID playerId = player.getUniqueId(); final PlayerData playerData = PlayerStorage.getPlayerData(playerId); final String modesetFromName = playerData.getModesetForWorld(event.getFrom().getUID()); updateModeset(player, player.getWorld().getUID(), modesetFromName); } private static void updateModeset(Player player, UUID worldId, String modesetFromName) { final UUID playerId = player.getUniqueId(); final PlayerData playerData = PlayerStorage.getPlayerData(playerId); final String originalModeset = playerData.getModesetForWorld(worldId); String modesetName = playerData.getModesetForWorld(worldId); // Get modesets allowed in to world Set allowedModesets = Config.getWorlds().get(worldId); if (allowedModesets == null || allowedModesets.isEmpty()) allowedModesets = Config.getModesets().keySet(); // If they don't have a modeset in toWorld yet if (modesetName == null) { // Try to use modeset of world they are coming from if (modesetFromName != null && allowedModesets.contains(modesetFromName)) modesetName = modesetFromName; else // Otherwise, if the from modeset is not allowed, use default for to world modesetName = allowedModesets.stream().findFirst().orElse(null); } // If the modeset changed, set and save if (originalModeset == null || !originalModeset.equals(modesetName)) { playerData.setModesetForWorld(worldId, modesetName); PlayerStorage.setPlayerData(playerId, playerData); PlayerStorage.scheduleSave(); Messenger.send(player, Config.getConfig().getString("mode-messages.mode-set", "&4ERROR: &rmode-messages.mode-set string missing"), modesetName ); } } @EventHandler(priority = EventPriority.LOWEST) public void onPlayerJoin(PlayerJoinEvent event) { final Player player = event.getPlayer(); updateModeset(player, player.getWorld().getUID(), null); } @EventHandler(ignoreCancelled = false) public void onWorldLoad(WorldLoadEvent event) { final World world = event.getWorld(); Config.addWorld(world); Messenger.info("Loaded configured world " + world.getName()); } @EventHandler(ignoreCancelled = false) public void onWorldUnload(WorldUnloadEvent event) { final World world = event.getWorld(); Config.removeWorld(world); Messenger.info("Unloaded configured world " + world.getName()); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/storage/PlayerData.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.storage; import org.bson.Document; import org.jetbrains.annotations.Nullable; import java.util.HashMap; import java.util.Map; import java.util.UUID; public class PlayerData { private Map modesetByWorld; public PlayerData() { modesetByWorld = new HashMap<>(); } public Map getModesetByWorld() { return modesetByWorld; } public void setModesetByWorld(Map modesetByWorld) { this.modesetByWorld = modesetByWorld; } public void setModesetForWorld(UUID worldId, String modeset) { modesetByWorld.put(worldId, modeset); } public @Nullable String getModesetForWorld(UUID worldId) { return modesetByWorld.get(worldId); } public static PlayerData fromDocument(Document doc) { final PlayerData playerData = new PlayerData(); final Document modesetByWorldDoc = (Document) doc.get("modesetByWorld"); if (modesetByWorldDoc != null) { for (Map.Entry entry : modesetByWorldDoc.entrySet()) { UUID worldId = UUID.fromString(entry.getKey()); String modeset = (String) entry.getValue(); playerData.setModesetForWorld(worldId, modeset); } } return playerData; } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/storage/PlayerDataCodec.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.storage; import org.bson.BsonReader; import org.bson.BsonWriter; import org.bson.Document; import org.bson.codecs.Codec; import org.bson.codecs.DecoderContext; import org.bson.codecs.DocumentCodec; import org.bson.codecs.EncoderContext; import java.util.Map; import java.util.UUID; public class PlayerDataCodec implements Codec { @Override public void encode(BsonWriter writer, PlayerData value, EncoderContext encoderContext) { final Document document = new Document(); Document modesetByWorldDoc = new Document(); for (Map.Entry entry : value.getModesetByWorld().entrySet()) { modesetByWorldDoc.put(entry.getKey().toString(), entry.getValue()); } document.put("modesetByWorld", modesetByWorldDoc); new DocumentCodec().encode(writer, document, encoderContext); } @Override public Class getEncoderClass() { return PlayerData.class; } @Override public PlayerData decode(BsonReader reader, DecoderContext decoderContext) { final Document document = new DocumentCodec().decode(reader, decoderContext); return PlayerData.fromDocument(document); } } ================================================ FILE: src/main/java/kernitus/plugin/OldCombatMechanics/utilities/storage/PlayerStorage.java ================================================ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ /* * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ package kernitus.plugin.OldCombatMechanics.utilities.storage; import kernitus.plugin.OldCombatMechanics.OCMMain; import org.bson.*; import org.bson.codecs.*; import org.bson.codecs.configuration.CodecRegistries; import org.bson.codecs.configuration.CodecRegistry; import org.bson.io.BasicOutputBuffer; import org.bukkit.Bukkit; import org.bukkit.scheduler.BukkitTask; import java.io.File; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.UUID; import java.util.concurrent.atomic.AtomicReference; import java.util.logging.Level; /** * Stores data associated with players to disk, persisting across server restarts. */ public class PlayerStorage { private static OCMMain plugin; private static Path dataFilePath; private static DocumentCodec documentCodec; private static Document data; private static final AtomicReference saveTask = new AtomicReference<>(); private static CodecRegistry codecRegistry; public static void initialise(OCMMain plugin) { PlayerStorage.plugin = plugin; dataFilePath = Paths.get(plugin.getDataFolder() + File.separator + "players.bson"); codecRegistry = CodecRegistries.fromRegistries( CodecRegistries.fromCodecs(new DocumentCodec()), // Explicitly provide a DocumentCodec CodecRegistries.fromCodecs(new PlayerDataCodec()), CodecRegistries.fromProviders(new BsonValueCodecProvider(), new ValueCodecProvider()) // For BSON values ); PlayerStorage.documentCodec = new DocumentCodec(codecRegistry); data = loadData(); saveTask.set(null); } private static Document loadData() { if (Files.notExists(dataFilePath)) return new Document(); try { byte[] data = Files.readAllBytes(dataFilePath); final BsonReader reader = new BsonBinaryReader(ByteBuffer.wrap(data)); return documentCodec.decode(reader, DecoderContext.builder().build()); } catch (IOException e) { plugin.getLogger().log(Level.SEVERE, "Error loading player data", e); } return new Document(); } public static void scheduleSave() { // Schedule a task for later, if there isn't one already scheduled saveTask.compareAndSet(null, Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, () -> { instantSave(); saveTask.set(null); }, 2400L) // Save after 2 minutes ); } public static void instantSave() { final BasicOutputBuffer outputBuffer = new BasicOutputBuffer(); final BsonWriter writer = new BsonBinaryWriter(outputBuffer); documentCodec.encode(writer, data, EncoderContext.builder().isEncodingCollectibleDocument(true).build()); writer.flush(); try { Files.write(dataFilePath, outputBuffer.toByteArray()); } catch (IOException e) { plugin.getLogger().log(Level.SEVERE, "Error saving player data", e); } finally { outputBuffer.close(); } } public static PlayerData getPlayerData(UUID uuid) { final Document playerDoc = (Document) data.get(uuid.toString()); if (playerDoc == null) { final PlayerData playerData = new PlayerData(); setPlayerData(uuid, playerData); scheduleSave(); return playerData; } final BsonDocument bsonDocument = new BsonDocumentWrapper<>(playerDoc, documentCodec); return codecRegistry.get(PlayerData.class).decode(bsonDocument.asBsonReader(), DecoderContext.builder().build()); } public static void setPlayerData(UUID uuid, PlayerData playerData) { // Create a BsonDocumentWriter to hold the encoded data BsonDocumentWriter writer = new BsonDocumentWriter(new BsonDocument()); // Get the PlayerDataCodec from the CodecRegistry PlayerDataCodec playerDataCodec = (PlayerDataCodec) codecRegistry.get(PlayerData.class); // Encode the PlayerData object to the writer playerDataCodec.encode(writer, playerData, EncoderContext.builder().isEncodingCollectibleDocument(true).build()); // Retrieve the BsonDocument BsonDocument bsonDocument = writer.getDocument(); // Convert the BsonDocument to a Document Document document = new Document(); bsonDocument.forEach((key, value) -> document.put(key, value.isDocument() ? new Document(value.asDocument()) : value)); // Put the Document into your data map data.put(uuid.toString(), document); } } ================================================ FILE: src/main/resources/config.yml ================================================ # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at https://mozilla.org/MPL/2.0/. # ############# OldCombatMechanics Plugin by kernitus and Rayzr522 ########## # # # Bukkit Page: http://dev.bukkit.org/bukkit-plugins/oldcombatmechanics/ # # Spigot Page: https://www.spigotmc.org/resources/oldcombatmechanics.19510/ # # GitHub Page: https://github.com/kernitus/BukkitOldCombatMechanics/ # # # # ########################################################################### always_enabled_modules: # Modules listed here are always enabled, regardless of modeset. # Each configurable module must appear in exactly one of: always_enabled_modules, disabled_modules, or a modeset. # Internal modules (modeset-listener, attack-cooldown-tracker, entity-damage-listener) are managed by the plugin and must not be listed. # If a module is listed in multiple sections or none, the plugin will throw an error. - "attack-frequency" - "old-armour-durability" - "old-fishing-knockback" - "fishing-rod-velocity" - "projectile-knockback" - "disable-crafting" - "update-checker" - "old-brewing-stand" - "disable-enderpearl-cooldown" disabled_modules: # Modules listed here are always disabled, regardless of modeset. # Of course, disabling a module which disables something will enable that something! - "disable-offhand" - "disable-sword-sweep-particles" - "disable-attack-sounds" - "chorus-fruit" - "old-burn-delay" - "attack-range" modesets: # Modesets are lists of modules that are enabled for a player in that mode. # You can create, remove, and rename as many modesets as you like by modifying the list below. # When in PvP, the modeset of the attacker is checked first. # If not PvP, the modeset of the defending entity is checked. # PlaceholderAPI: %ocm_modeset% old: - "disable-attack-cooldown" - "disable-sword-sweep" - "old-tool-damage" - "sword-blocking" - "shield-damage-reduction" - "old-golden-apples" - "old-player-knockback" - "old-player-regen" - "old-armour-strength" - "old-potion-effects" - "old-critical-hits" new: - "old-golden-apples" worlds: # These are the modesets available in each world. # If player has no modeset when moving worlds they'll be assigned first mode in list, # unless the mode from the world they are coming from is also available in the new world. # Worlds not specified below will have all modesets available. world: [ "old", "new" ] world_nether: [ "old", "new" ] world_the_end: [ "old", "new" ] # old_world: ["old"] # brave_new_world: ["new"] mode-messages: # Messages used when changing player mode # To disable any message, leave the corresponding string empty (e.g., mode-status: ""). # This applies to all messages in the configuration. mode-status: "&bYour current modeset is: &7%s" message-usage: "&eYou can use &c/ocm mode [player] &eto change modeset" invalid-modeset: "&cPlease specify a valid modeset!" invalid-player: "&cPlease specify a valid player!" mode-set: "&2Set modeset to &7%s" # ######################## # COMBAT MODULE SETTINGS # ######################## disable-attack-cooldown: # This is to disable the attack cooldown # What to set the attack speed to. Default for 1.9 is 4, at least 40 is needed for no cooldown. generic-attack-speed: 40 # Optional per-material override for the item in the player's main hand. # Materials not listed here fall back to generic-attack-speed. # The bundled defaults keep most items at no cooldown, while trident, mace, # and spears retain more vanilla-like attack speeds. # Newer-version material keys that are unavailable on the current server are # ignored safely. held-item-attack-speeds: TRIDENT: 1.1 MACE: 0.6 WOODEN_SPEAR: 1.54 GOLDEN_SPEAR: 1.05 STONE_SPEAR: 1.33 COPPER_SPEAR: 1.18 IRON_SPEAR: 1.05 DIAMOND_SPEAR: 0.95 NETHERITE_SPEAR: 0.87 attack-frequency: # Allows changing the player invulnerability between hits # The hit delay to apply. Default for 1.9+ is 20 ticks (1 second) playerDelay: 18 mobDelay: 16 attack-range: # Applies 1.8-style hit detection (smaller hitbox margin, shorter creative reach). # Paper 1.21.11+ only; auto-disables on older/Paperless servers. # Note: this module re-applies reach when items are held and strips it when swapping/dropping to avoid tainting stored items. # Very frequent hotbar swapping may have a small performance cost. min-range: 0.0 max-range: 3.0 min-creative-range: 0.0 max-creative-range: 4.0 hitbox-margin: 0.1 mob-factor: 1.0 old-tool-damage: # This is to set the tool damage as in pre-1.9 # IMPORTANT: Also enable disable-sword-sweep module or sweeps will have the damage value of the weapon in hand # NOTE: this will modify the damage, however the vanilla attribute tooltip will still show the 1.9+ values. # The tooltip section below is enabled by default so players can see the configured damage in-game. # Use old sharpness calculations, i.e. each level adds 1.25 damage # In 1.9+, sharpness adds 1 + 0.5 * level damage old-sharpness: true tooltip: # Optionally adds a lore line showing the configured damage from old-tool-damage.damages (the actual damage OCM applies). # This is a cosmetic helper to reduce confusion, but can interact with other plugins that rewrite item lore. enabled: true prefix: "OCM Damage:" # Damage values are in 1.9+ "actual damage" terms (1 damage = half a heart). # In 1.8, the client tooltip showed "+X Attack Damage", where X = (actual_damage - 1) because the base unarmed damage is 1. damages: # Axe damages GOLD_AXE: 4 WOOD_AXE: 4 STONE_AXE: 5 IRON_AXE: 6 DIAMOND_AXE: 7 NETHERITE_AXE: 8 COPPER_AXE: 6 # Shovel damages GOLD_SPADE: 2 WOOD_SPADE: 2 STONE_SPADE: 3 IRON_SPADE: 4 DIAMOND_SPADE: 5 NETHERITE_SPADE: 6 COPPER_SPADE: 3 # Sword damages GOLD_SWORD: 5 WOOD_SWORD: 5 STONE_SWORD: 6 IRON_SWORD: 7 DIAMOND_SWORD: 8 NETHERITE_SWORD: 9 COPPER_SWORD: 6 # Pickaxe damages GOLD_PICKAXE: 3 WOOD_PICKAXE: 3 STONE_PICKAXE: 4 IRON_PICKAXE: 5 DIAMOND_PICKAXE: 6 NETHERITE_PICKAXE: 7 COPPER_PICKAXE: 4 # Hoe damages GOLD_HOE: 1 WOOD_HOE: 1 STONE_HOE: 1 IRON_HOE: 1 DIAMOND_HOE: 1 NETHERITE_HOE: 1 COPPER_HOE: 1 # Trident and mace TRIDENT: 8 TRIDENT_THROWN: 8 MACE: 6 old-critical-hits: # Makes critical hits work like in 1.8 # With a critical hit, the damage will be multiplied by 1.5 # In 1.9, the user must also not be sprinting for it to be a crit world: [ ] # What the damage, after applying potions effects, is multiplied by multiplier: 1.5 # Whether to allow crits while sprinting. 1.8: true, 1.9: false allow-sprinting: true old-player-regen: # This is to make players' regeneration act mostly like it did in pre-1.9 # Based on https://minecraft.gamepedia.com/Hunger?oldid=948685 # How often a player should regenerate health, in milliseconds (In 1.8: 4 seconds) # The foodTickerTimer might not be perfectly accurate so we give it ~10ms of leeway interval: 3990 # How many half-hearts the player should heal by, every seconds specified above amount: 1 # How much exhaustion the player should get from healing. In 1.8: 3 In 1.9: 4 In 1.11: 6 # If, after adding this, Minecraft finds the value is above 4, it subtracts 4 # and either reduces saturation or, if saturation is 0, reduces food level by 1 (1/2 a stick) exhaustion: 3 # ######################## # ARMOUR # ######################## old-armour-strength: # This is to make armour calculations like in 1.8 # Based on this: https://minecraft.gamepedia.com/index.php?title=Armor&oldid=909187 # Whether to introduce randomness in the calculation, as in 1.8 randomness: true old-armour-durability: # This makes armour take a constant amount of durability damage (except for explosions) # By how much to reduce durability every attack. 1.8 default is 1 reduction: 1 # ######################## # SWEEP, SHIELDS & BLOCKING # ######################## shield-damage-reduction: # This module allows changing the damage reduction behaviour of shields # How much damage blocking should reduce # Firstly, amount is subtracted, then value is multiplied by percentage # 1.8: (damage - 1) * 50% 1.9: damage * 33% 1.11: damage * 0% # Damage reduction = (damage - damageReductionAmount) * damageReductionPercentage / 100 generalDamageReductionAmount: 1 generalDamageReductionPercentage: 50 # This value works the same but is exclusively for projectile damage # Set amount to 0 and percentage to 100 for 1.8 behaviour, i.e. arrows go through shields projectileDamageReductionAmount: 1 projectileDamageReductionPercentage: 50 sword-blocking: # This is to allow players to block with swords again, by getting a shield while they hold right click with a sword # Paper 1.20.5+ uses a consumable-based blocking animation. Older/Paperless servers fall back to an offhand shield. # With ViaVersion, clients older than 1.20.5 will also fall back to the shield behaviour. # Set to false to disable the Paper animation path entirely and always use the legacy shield fallback. paper-animation: true # How often, in ticks, OCM should check if the player is still blocking with a shield, and remove it if not # If this is too fast, the player will have their shield disappear before they're able to block again causing a slight delay # If this is too slow, players will have a shield in their hand well after they've stopped blocking # 20 ticks = 1 second restoreDelay: 40 # Whether to require players to have oldcombatmechanics.swordblock permission to block with a sword use-permission: false disable-sword-sweep: # This is to disable the sword sweep attack # With PacketEvents, particle effect is also removed disable-sword-sweep-particles: # This is to disable the sword sweep attack particles # Requires PacketEvents # ######################## # KNOCKBACK # ######################## old-player-knockback: # This is to change knockback players receive from attacks. Default values are as in 1.8. # # Practice servers tend to use lower knockback, for example: # knockback-horizontal: 0.35 # knockback-vertical: 0.35 # knockback-vertical-limit: 0.4 # knockback-extra-horizontal: 0.425 # knockback-extra-vertical: 0.085 # # Minigame servers use higher vertical knockback and lower horizontal knockback, exact values are unknown. # Horizontal knockback is reduced by 40% for every successful attack by the player, with no limit # Increase to make clicking more important, decrease to make it less important knockback-horizontal: 0.4 # Vertical knockback is not reduced by clicking faster # Increase to make clicking less important, decrease to make clicking more important knockback-vertical: 0.4 # Vertical knockback limit is applied after base vertical knockback # This limit can be exceeded by sprint hitting or knockback enchantments, from the extra vertical knockback knockback-vertical-limit: 0.4 # Extra horizontal knockback is applied for each level of knockback enchant, and for sprinting # Increase to make sprint resetting (w-tapping) more important, decrease to make it less important # Increase to make clicking more important, decrease to make clicking less important knockback-extra-horizontal: 0.5 # Extra vertical knockback is applied for each level of knockback enchant, and for sprinting # Increase to make sprint resetting (w-tapping) more important, decrease to make it less important # Increase to make clicking less important, decrease to make clicking more important knockback-extra-vertical: 0.1 # Should knockback resistance be enabled? (e.g. netherite armour knockback resistance) enable-knockback-resistance: false old-fishing-knockback: # This is to make the knockback of players when they get hit by a fishing bobber the same as it was in pre-1.9 # This is the damage done by the fishing rod attack damage: 0.0001 # This is to cancel dragging in the entity attached to the fishing rod when reeling in, like in 1.8 # Options: all, players, mobs, none. players allows compatibility with WorldGuard pvp-deny regions cancelDraggingIn: players # Whether to also give knockback on non-player living entities (e.g. mobs) knockbackNonPlayerEntities: false # This is the delay in milliseconds in-between rod damage, so the player hit has time to fall back down hitCooldown: 1000 fishing-rod-velocity: # In 1.9+ fishing rods go 8 blocks instead of 12 blocks # This is due to both gravity and initial launch speed # Set to true to revert back to the old calculations and gravity projectile-knockback: # This adds knockback and/or damage to players when they get hit by snowballs, eggs & enderpearls # This has been a Bukkit bug for so long people thought it was vanilla when it was patched # This is the damage done by each projectile damage: snowball: 0.0001 egg: 0.0001 ender_pearl: 0.0001 # ######################## # GAPPLES & POTIONS # ######################## old-golden-apples: # This is to change the behaviour / crafting of golden apples to how it was in pre-1.9 # WARNING: If on 1.12 or above and you disable this module you must reload the server for the recipe to disappear # Cooldown between eating the apples, in seconds cooldown: # The cooldown for normal golden apples # PlaceholderAPI: %ocm_gapple_cooldown% normal: 0 # Message when user tries to eat golden apple during cooldown. Leave empty to disable. message-normal: "&ePlease wait %seconds%s before eating another golden apple." # The cooldown for enchanted golden apples # PlaceholderAPI: %ocm_napple_cooldown% enchanted: 0 # Message when user tries to eat enchanted golden apple during cooldown. Leave empty to disable. message-enchanted: "&ePlease wait %seconds%s before eating another enchanted golden apple." # Whether the two apple types share a cooldown. # If this is true: # 1. Eating any apple resets both cooldowns # 2. Each apple type can only be eaten when its cooldown time is over # This means that when you eat *any* apple you start two parallel cooldowns: One for enchanted and one # for normal apples. Each type can only be eaten when its cooldown is over. # Once any apple is eaten, both cooldowns are restarted, so you can not eat either type again # before its full cooldown is over. # 3. To have the plugin treat normal and enchanted golden apples as having the same cooldown, # then set the same cooldown time and enable shared mode. (This was the old mode) # If this is false: # Eating an enchanted apple will prevent any *enchanted* apple type from being eaten before the cooldown is over # Eating a normal apple will prevent any *normal* apple type from being eaten before the normal cooldown is over is-shared: false # If you want to allow enchanted golden apple crafting enchanted-golden-apple-crafting: true # Enabling this makes the potion effects gained by eating golden apples # and enchanted golden apples the same as it was in pre-1.9 old-potion-effects: true # Potion effects for golden apples # Duration is in seconds # Amplifier is the potion level-1, so Regeneration IV would be amplifier 3 golden-apple-effects: regeneration: duration: 5 amplifier: 1 absorption: duration: 120 amplifier: 0 # Potion effects for enchanted golden apples enchanted-golden-apple-effects: regeneration: duration: 30 amplifier: 4 resistance: duration: 300 amplifier: 0 fire_resistance: duration: 300 amplifier: 0 absorption: duration: 120 amplifier: 0 # Enable this if you have another plugin which adds a crafting recipe for # enchanted golden apples (requires server restart) no-conflict-mode: false old-potion-effects: # This is to restore the 1.8 potion effects and duration # DURATION: (in seconds) potion-durations: drinkable: regeneration: 45 strong_regeneration: 22 long_regeneration: 120 swiftness: 180 strong_swiftness: 90 long_swiftness: 480 fire_resistance: 180 long_fire_resistance: 480 poison: 45 strong_poison: 22 long_poison: 120 night_vision: 180 long_night_vision: 480 weakness: 90 long_weakness: 240 strength: 180 strong_strength: 90 long_strength: 480 slowness: 90 long_slowness: 240 leaping: 180 strong_leaping: 90 long_leaping: 480 water_breathing: 180 long_water_breathing: 480 invisibility: 180 long_invisibility: 480 # 1.9+ potions. You can add more as needed. # Make sure to also add to splash section below. luck: 300 slow_falling: 90 long_slow_falling: 240 splash: regeneration: 33 strong_regeneration: 16 long_regeneration: 90 swiftness: 135 strong_swiftness: 67 long_swiftness: 360 fire_resistance: 135 long_fire_resistance: 360 poison: 33 strong_poison: 16 long_poison: 90 night_vision: 180 long_night_vision: 480 weakness: 90 long_weakness: 240 strength: 135 strong_strength: 67 long_strength: 360 slowness: 67 long_slowness: 180 leaping: 135 strong_leaping: 67 long_leaping: 360 water_breathing: 135 long_water_breathing: 360 invisibility: 135 long_invisibility: 360 # 1.9+ potions. You can add more as needed luck: 300 slow_falling: 90 long_slow_falling: 240 # EFFECTS # If 'multiplier' is true value is multiplied by base tool damage. If 'addend' it is added. # If both true, it is first increased by 1 then multiplied (same as +xx%) # Strength potion # 1.9: I = +3; II = +6; 1.8: I = +130%; II = +260% strength: modifier: 1.3 multiplier: true addend: true # Weakness potion # 1.9 value: -4 1.8 value: -0.5 weakness: modifier: -0.5 multiplier: false # ######################## # MISCELLANEOUS # ######################## disable-crafting: # Disable the crafting of specified items # List of denied items denied: - shield # Show the user a message if they try to craft a blacklisted item showMessage: true message: "&cYou cannot craft that item!" disable-offhand: # Disable the usage of the offhand # Won't affect sword-blocking module # Whether the following list allows items or blocks them whitelist: true # List of items that should be allowed/blocked # Example: [diamond_sword,BOW] items: [ ] # Message to send user when denied. Set to '' to disable denied-message: "&cOff-hand is disabled" old-brewing-stand: # Automatically refuels brewing stands disable-enderpearl-cooldown: # Disables enderpearl cooldown # The cooldown, in seconds # PlaceholderAPI: %ocm_enderpearl_cooldown% cooldown: 0 # Show the user a message if they try to use an enderpearl and the cooldown has not expired yet showMessage: true message: "&cYou must wait &7%ds&c before using an enderpearl again!" chorus-fruit: # This makes the chorus fruit behaviour configurable # The maximum distance the fruit can teleport the player. This a PER AXIS value, so this outlines a cube with # 2 * max-teleportation-distance as the side length # Vanilla default is 8. # Setting this to 0 disables chorus fruit teleport. # Setting this to a value greater than 8 MIGHT CAUSE CONFLICTS with bukkit's internal anti cheat # and *potentially* any other anti-cheat you use. Please make sure this is not an issue before increasing # this value. max-teleportation-distance: 8 # Whether to prevent eating the fruit completely. This also prevents the teleportation. prevent-eating: false # The saturation value of the chorus fruit. # Vanilla default is 2.4 saturation-value: 2.4 # The hunger value of the chorus fruit. # Vanilla default is 4 (2 bars) hunger-value: 4 old-burn-delay: # This makes it so entities will immediately start to burn when entering fire # How long, in ticks, entities should be on fire for after not being in direct contact anymore fire-ticks: 120 disable-attack-sounds: # Disables attack sounds that were added with 1.9+ # Requires PacketEvents # The sounds that will be blocked by this module blocked-sound-names: - "ENTITY_PLAYER_ATTACK_STRONG" - "ENTITY_PLAYER_ATTACK_SWEEP" - "ENTITY_PLAYER_ATTACK_NODAMAGE" - "ENTITY_PLAYER_ATTACK_KNOCKBACK" - "ENTITY_PLAYER_ATTACK_CRIT" - "ENTITY_PLAYER_ATTACK_WEAK" # ######################## # SPECIAL SETTINGS BELOW # # ######################## message-prefix: "&6[OCM]&r" # This is to toggle the update checker update-checker: # Whether to check for updates and notify players with the oldcombatmechanics.notify permission # Whether to automatically download an update of the plugin # The update is applied on the next restart/reload of the server # Auto update is disabled if Spigot version is below 1.18.1 and force-below-1-18-1-config-upgrade is false # This is to prevent accidentally resetting the config auto-update: true # Whether to force config upgrade even in Spigot versions below 1.18.1 # This is not advised, as all the comments would be removed force-below-1-18-1-config-upgrade: false # This enables command argument completion when pressing tab command-completer: enabled: true # This enables debug messages, only enable when troubleshooting debug: enabled: false # DO NOT CHANGE THIS NUMBER AS IT WILL RESET YOUR CONFIG config-version: 73 ================================================ FILE: src/main/resources/plugin.yml ================================================ # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at https://mozilla.org/MPL/2.0/. main: kernitus.plugin.OldCombatMechanics.OCMMain name: OldCombatMechanics version: ${pluginVersion} authors: [kernitus, Rayzr522] description: Reverts to pre-1.9 combat mechanics website: https://github.com/kernitus/BukkitOldCombatMechanics load: POSTWORLD softdepend: [PlaceholderAPI] api-version: 1.13 commands: oldcombatmechanics: description: OldCombatMechanics's main command aliases: [ocm] permission: oldcombatmechanics.commands permissions: oldcombatmechanics.*: description: Gives access to all OCM permissions default: op children: oldcombatmechanics.commands: true oldcombatmechanics.notify: true oldcombatmechanics.mode: true oldcombatmechanics.mode.own: true oldcombatmechanics.mode.others: true oldcombatmechanics.swordblock: true oldcombatmechanics.commands: description: Allows the usage of OCM commands default: op oldcombatmechanics.notify: description: Notifies of new OCM updates default: op oldcombatmechanics.mode: description: Allows player to use /ocm mode to check own modeset default: op oldcombatmechanics.mode.own: description: Allows player to use /ocm mode to change own modeset default: op children: oldcombatmechanics.mode: true oldcombatmechanics.mode.others: description: Allows player to use /ocm mode to change other players' modeset default: op children: oldcombatmechanics.mode: true oldcombatmechanics.swordblock: description: Allows players to block with sword default: op