diff --git a/Plugins/Nautilus.Game.Arcade/.settings/org.eclipse.jdt.core.prefs b/Plugins/Nautilus.Game.Arcade/.settings/org.eclipse.jdt.core.prefs index 7341ab168..3994e7cb1 100644 --- a/Plugins/Nautilus.Game.Arcade/.settings/org.eclipse.jdt.core.prefs +++ b/Plugins/Nautilus.Game.Arcade/.settings/org.eclipse.jdt.core.prefs @@ -9,3 +9,287 @@ org.eclipse.jdt.core.compiler.debug.sourceFile=generate org.eclipse.jdt.core.compiler.problem.assertIdentifier=error org.eclipse.jdt.core.compiler.problem.enumIdentifier=error org.eclipse.jdt.core.compiler.source=1.7 +org.eclipse.jdt.core.formatter.align_type_members_on_columns=false +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_assignment=0 +org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16 +org.eclipse.jdt.core.formatter.alignment_for_compact_if=16 +org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80 +org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0 +org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16 +org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0 +org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80 +org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16 +org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16 +org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16 +org.eclipse.jdt.core.formatter.blank_lines_after_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_after_package=1 +org.eclipse.jdt.core.formatter.blank_lines_before_field=0 +org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0 +org.eclipse.jdt.core.formatter.blank_lines_before_imports=1 +org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1 +org.eclipse.jdt.core.formatter.blank_lines_before_method=1 +org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1 +org.eclipse.jdt.core.formatter.blank_lines_before_package=0 +org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1 +org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1 +org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=next_line +org.eclipse.jdt.core.formatter.brace_position_for_block=next_line +org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=next_line +org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=next_line +org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_lambda_body=next_line +org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=next_line +org.eclipse.jdt.core.formatter.brace_position_for_switch=next_line +org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=next_line +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false +org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false +org.eclipse.jdt.core.formatter.comment.format_block_comments=true +org.eclipse.jdt.core.formatter.comment.format_header=false +org.eclipse.jdt.core.formatter.comment.format_html=true +org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true +org.eclipse.jdt.core.formatter.comment.format_line_comments=true +org.eclipse.jdt.core.formatter.comment.format_source_code=true +org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true +org.eclipse.jdt.core.formatter.comment.indent_root_tags=true +org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert +org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert +org.eclipse.jdt.core.formatter.comment.line_length=80 +org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true +org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true +org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=false +org.eclipse.jdt.core.formatter.compact_else_if=true +org.eclipse.jdt.core.formatter.continuation_indentation=2 +org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2 +org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off +org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on +org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false +org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true +org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true +org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_empty_lines=false +org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true +org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true +org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false +org.eclipse.jdt.core.formatter.indentation.size=4 +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert +org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert +org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert +org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert +org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert +org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert +org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert +org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert +org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert +org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert +org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert +org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert +org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert +org.eclipse.jdt.core.formatter.join_lines_in_comments=true +org.eclipse.jdt.core.formatter.join_wrapped_lines=true +org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=true +org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false +org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false +org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false +org.eclipse.jdt.core.formatter.lineSplit=80 +org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false +org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false +org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0 +org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1 +org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true +org.eclipse.jdt.core.formatter.tabulation.char=tab +org.eclipse.jdt.core.formatter.tabulation.size=4 +org.eclipse.jdt.core.formatter.use_on_off_tags=false +org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false +org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true +org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true +org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true diff --git a/Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/skywars/SkyWars.java b/Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/skywars/SkyWars.java index 0b93844ed..82e9fea97 100644 --- a/Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/skywars/SkyWars.java +++ b/Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/game/games/skywars/SkyWars.java @@ -2,161 +2,836 @@ package nautilus.game.arcade.game.games.skywars; import java.util.ArrayList; import java.util.HashSet; +import java.util.Iterator; -import org.bukkit.Material; -import org.bukkit.block.Block; -import org.bukkit.block.BlockFace; -import org.bukkit.event.EventHandler; -import org.bukkit.event.block.BlockPlaceEvent; - +import mineplex.core.common.util.C; +import mineplex.core.common.util.F; +import mineplex.core.common.util.MapUtil; +import mineplex.core.common.util.UtilAction; import mineplex.core.common.util.UtilBlock; +import mineplex.core.common.util.UtilEvent; +import mineplex.core.common.util.UtilInv; import mineplex.core.common.util.UtilMath; +import mineplex.core.common.util.UtilPlayer; +import mineplex.core.common.util.UtilServer; +import mineplex.core.common.util.UtilTime; +import mineplex.core.loot.ChestLoot; +import mineplex.core.loot.RandomItem; import mineplex.core.updater.UpdateType; import mineplex.core.updater.event.UpdateEvent; +import mineplex.minecraft.game.core.combat.event.CombatDeathEvent; import nautilus.game.arcade.ArcadeManager; import nautilus.game.arcade.GameType; import nautilus.game.arcade.events.GameStateChangeEvent; +import nautilus.game.arcade.game.Game; import nautilus.game.arcade.game.SoloGame; +import nautilus.game.arcade.game.games.skywars.data.TNTGenerator; +import nautilus.game.arcade.game.games.skywars.kits.KitDigger; +import nautilus.game.arcade.game.games.skywars.kits.KitJumper; +import nautilus.game.arcade.game.games.skywars.kits.KitZoo; import nautilus.game.arcade.kit.Kit; +import nautilus.game.arcade.ore.OreHider; -public class SkyWars extends SoloGame { +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.block.BlockState; +import org.bukkit.block.Chest; +import org.bukkit.block.DoubleChest; +import org.bukkit.entity.Creature; +import org.bukkit.entity.Player; +import org.bukkit.entity.TNTPrimed; +import org.bukkit.entity.Zombie; +import org.bukkit.event.EventHandler; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.event.block.BlockBurnEvent; +import org.bukkit.event.block.BlockFadeEvent; +import org.bukkit.event.block.BlockSpreadEvent; +import org.bukkit.event.block.LeavesDecayEvent; +import org.bukkit.event.entity.EntityCombustEvent; +import org.bukkit.event.entity.EntityExplodeEvent; +import org.bukkit.event.entity.ItemDespawnEvent; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerPickupItemEvent; +import org.bukkit.inventory.ItemStack; - +@SuppressWarnings("deprecation") +public class SkyWars extends SoloGame +{ + private ArrayList _worldBlocks = new ArrayList(); + private ChestLoot _baseLoot = new ChestLoot(true); + private HashSet _lootedBlocks = new HashSet(); + private TNTGenerator _tnt; + private boolean _already; + private ArrayList _mobs = new ArrayList(); + private OreHider _ore; + private double _oreDensity = 1.99D; - private ArrayList _blocks = new ArrayList(); - - public SkyWars(ArcadeManager manager) { - super(manager, GameType.Skywars, new Kit[] {}, new String[] { - "Battle in the sky!", - "Collect loot from chests to get better armor", - "Last player alive wins!" }); - - PrepareFreeze = false; - - StrictAntiHack = true; + public SkyWars(ArcadeManager manager) + { + super(manager, GameType.Skywars, + new Kit[] + { new KitDigger(manager), new KitJumper(manager), + new KitZoo(manager) }, new String[] + { "Free for all battle in the sky!", + "Collect loot from chests", "Last player alive wins!" }); - GameTimeout = 1500000; + this.PrepareFreeze = true; - QuitDropItems = true; + this.StrictAntiHack = true; - WorldTimeSet = 0; - WorldBoundaryKill = false; + this.GameTimeout = 1500000L; - SpawnDistanceRequirement = 48; + this.QuitDropItems = true; - DamageSelf = true; - DamageTeamSelf = true; + this.WorldTimeSet = 0; + this.WorldBoundaryKill = false; - DeathDropItems = true; + this.SpawnDistanceRequirement = 48; - ItemDrop = true; - ItemPickup = true; + this.DamageSelf = true; + this.DamageTeamSelf = true; - InventoryClick = true; - InventoryOpenBlock = true; - InventoryOpenChest = true; + this.DeathDropItems = true; - PlaySoundGameStart = false; - PrepareTime = 15000; - - VersionRequire1_8 = true; - - _help = new String[] - { - "This game is still under heavy development!", - "Don't walk near the edge... You can get knocked off!", - "Access the TNT generator at mid to fire TNT!" - }; - + this.ItemDrop = true; + this.ItemPickup = true; + + this.BlockBreak = true; + this.BlockPlace = true; + + this.InventoryClick = true; + this.InventoryOpenBlock = true; + this.InventoryOpenChest = true; + + this.PlaySoundGameStart = true; + this.PrepareTime = 10000L; + + this.VersionRequire1_8 = true; + + this._help = new String[] + { "This game is still under heavy development!", + "Collect loot from chests to gear up!", + "Don't stand near the edge... You can get knocked off!" }; + + setupLoot(); + + this._ore = new OreHider(); + + setHasAlready(false); } - - @SuppressWarnings("deprecation") - @EventHandler - public void CreateRandomChests(GameStateChangeEvent event) + public void ParseData() { - if (event.GetState() != GameState.Recruit) - return; - - HashSet ignore = new HashSet(); - - ignore.add(Material.LEAVES); - - int xDiff = WorldData.MaxX - WorldData.MinX; - int zDiff = WorldData.MaxZ - WorldData.MinZ; - - int done = 0; - - while (done < 40) + int x; + int z; + for (int y = this.WorldData.MinY; y < this.WorldData.MaxY; y++) { + for (x = this.WorldData.MinX; x < this.WorldData.MaxX; x++) + { + for (z = this.WorldData.MinZ; z < this.WorldData.MaxZ; z++) + { + Block block = this.WorldData.World.getBlockAt(x, y, z); + if ((block.getType() != Material.AIR) + && (!block.isLiquid())) + { + this._worldBlocks.add(block); + } + } + } + } + for (Location loc : this.WorldData.GetDataLocs("LIME")) + { + this._tnt = new TNTGenerator(this, loc); + } + Iterator mobIterator = this._mobs.iterator(); + while (mobIterator.hasNext()) + { + Creature mob = (Creature) mobIterator.next(); + if (!mob.isValid()) + { + mob.remove(); + mobIterator.remove(); + } + } + for (Location loc : this.WorldData.GetCustomLocs("20")) + { + if (this._mobs.size() < 20) + { + this.CreatureAllowOverride = true; + Zombie zombie = (Zombie) loc.getWorld() + .spawn(loc, Zombie.class); + zombie.setRemoveWhenFarAway(false); + zombie.setCustomName(C.cDRed + "Killer Zombie"); + zombie.setCustomNameVisible(true); + this._mobs.add(zombie); + this.CreatureAllowOverride = false; + } + } + ParseOre(this.WorldData.GetCustomLocs("36")); + } - Block block = UtilBlock.getHighest(WorldData.World, WorldData.MinX + UtilMath.r(xDiff), - WorldData.MinZ + UtilMath.r(zDiff), ignore); + private void ParseOre(ArrayList teamOre) + { + System.out.println(F.sys("Test", "Parsing ores...")); + int coal = (int) (teamOre.size() / 32.0D * this._oreDensity); + int iron = (int) (teamOre.size() / 24.0D * this._oreDensity); + int gold = (int) (teamOre.size() / 64.0D * this._oreDensity); + int diamond = 1 + (int) (teamOre.size() / 128.0D * this._oreDensity); - if (!UtilBlock.airFoliage(block) || !UtilBlock.solid(block.getRelative(BlockFace.DOWN))) - continue; + int gravel = (int) (teamOre.size() / 64.0D * this._oreDensity); - block.setTypeIdAndData(Material.CHEST.getId(), (byte) UtilMath.r(4), true); - done++; + int lowY = 256; + int highY = 0; + for (Location loc : teamOre) + { + if (loc.getBlockY() < lowY) + { + lowY = loc.getBlockY(); + } + if (loc.getBlockY() > highY) + { + highY = loc.getBlockY(); + } + loc.getBlock().setTypeId(1); + } + int varY = highY - lowY; + for (int i = 0; (i < gravel) && (!teamOre.isEmpty()); i++) + { + int attempts = 20; + int id = 0; + while (attempts > 0) + { + id = UtilMath.r(teamOre.size()); + + double height = (((Location) teamOre.get(id)).getBlockY() - lowY) + / varY; + if (height > 0.8D) + { + break; + } + if ((height > 0.6D) && (Math.random() > 0.4D)) + { + break; + } + if ((height > 0.4D) && (Math.random() > 0.6D)) + { + break; + } + if ((height > 0.2D) && (Math.random() > 0.8D)) + { + break; + } + } + CreateOre((Location) teamOre.remove(id), Material.GRAVEL, 6); + System.out.println(F.sys("Test", "Gravel created")); + } + for (int i = 0; (i < coal) && (!teamOre.isEmpty()); i++) + { + int attempts = 20; + int id = 0; + while (attempts > 0) + { + id = UtilMath.r(teamOre.size()); + + double height = (((Location) teamOre.get(id)).getBlockY() - lowY) + / varY; + if (height > 0.8D) + { + break; + } + if ((height > 0.6D) && (Math.random() > 0.4D)) + { + break; + } + if ((height > 0.4D) && (Math.random() > 0.6D)) + { + break; + } + if ((height > 0.2D) && (Math.random() > 0.8D)) + { + break; + } + } + CreateOre((Location) teamOre.remove(id), Material.COAL_ORE, 6); + System.out.println(F.sys("Test", "Coal ore created")); + } + for (int i = 0; (i < iron) && (!teamOre.isEmpty()); i++) + { + int id = UtilMath.r(teamOre.size()); + + CreateOre((Location) teamOre.remove(id), Material.IRON_ORE, 3); + System.out.println(F.sys("Test", "Iron ore created")); + } + for (int i = 0; (i < gold) && (!teamOre.isEmpty()); i++) + { + int attempts = 20; + int id = 0; + while (attempts > 0) + { + id = UtilMath.r(teamOre.size()); + + double height = (((Location) teamOre.get(id)).getBlockY() - lowY) + / varY; + if ((height > 0.8D) && (Math.random() > 0.8D)) + { + break; + } + if ((height > 0.6D) && (Math.random() > 0.7D)) + { + break; + } + if ((height > 0.4D) && (Math.random() > 0.6D)) + { + break; + } + if ((height > 0.2D) && (Math.random() > 0.4D)) + { + break; + } + if (Math.random() > 0.2D) + { + break; + } + } + CreateOre((Location) teamOre.remove(id), Material.GOLD_ORE, 3); + System.out.println(F.sys("Test", "Gold ore created")); + } + for (int i = 0; (i < diamond) && (!teamOre.isEmpty()); i++) + { + int attempts = 20; + int id = 0; + while (attempts > 0) + { + id = UtilMath.r(teamOre.size()); + + double height = (((Location) teamOre.get(id)).getBlockY() - lowY) + / varY; + if (height <= 0.8D) + { + if ((height > 0.6D) && (Math.random() > 0.9D)) + { + break; + } + if ((height > 0.4D) && (Math.random() > 0.7D)) + { + break; + } + if ((height <= 0.2D) || (Math.random() <= 0.5D)) + { + break; + } + break; + } + } + CreateOre((Location) teamOre.remove(id), Material.DIAMOND_ORE, 2); + System.out.println(F.sys("Test", "Diamond ore created")); } } - - @EventHandler - public void BlockPlace(BlockPlaceEvent event) + + private void CreateOre(Location loc, Material type, int amount) { - if (event.isCancelled()) - return; - - _blocks.add(event.getBlock()); + double bonus = Math.random() + 1.0D; + + amount = (int) (amount * bonus); + + int attempts = 100; + while ((amount > 0) && (attempts > 0)) + { + attempts--; + + BlockFace faceXZ = BlockFace.SELF; + BlockFace faceY = BlockFace.SELF; + if (Math.random() > 0.2D) + { + int rFace = UtilMath.r(6); + if (rFace == 0) + { + faceY = BlockFace.UP; + } + else if (rFace == 1) + { + faceY = BlockFace.DOWN; + } + else if (rFace == 2) + { + faceXZ = BlockFace.NORTH; + } + else if (rFace == 3) + { + faceXZ = BlockFace.SOUTH; + } + else if (rFace == 4) + { + faceXZ = BlockFace.EAST; + } + else + { + faceXZ = BlockFace.WEST; + } + } + else + { + int rFace = UtilMath.r(3); + if (rFace == 0) + { + faceY = BlockFace.SELF; + } + else if (rFace == 1) + { + faceY = BlockFace.UP; + } + else + { + faceY = BlockFace.DOWN; + } + if (faceY == BlockFace.SELF) + { + rFace = UtilMath.r(4); + if (rFace == 0) + { + faceXZ = BlockFace.NORTH_EAST; + } + else if (rFace == 1) + { + faceXZ = BlockFace.NORTH_WEST; + } + else if (rFace == 2) + { + faceXZ = BlockFace.SOUTH_EAST; + } + else + { + faceXZ = BlockFace.SOUTH_WEST; + } + } + else + { + rFace = UtilMath.r(4); + if (rFace == 0) + { + faceXZ = BlockFace.NORTH; + } + else if (rFace == 1) + { + faceXZ = BlockFace.SOUTH; + } + else if (rFace == 2) + { + faceXZ = BlockFace.EAST; + } + else + { + faceXZ = BlockFace.WEST; + } + } + } + if (loc.getBlock().getRelative(faceY).getRelative(faceXZ).getType() == Material.STONE) + { + loc = loc.getBlock().getRelative(faceY).getRelative(faceXZ) + .getLocation(); + + this._ore.AddOre(loc, type); + + amount--; + } + } } - - @SuppressWarnings("deprecation") + @EventHandler public void BlockUpdate(UpdateEvent event) { if (event.getType() != UpdateType.TICK) + { return; - + } if (!IsLive()) + { return; - - if (_blocks.isEmpty()) + } + if (this._worldBlocks.isEmpty()) + { return; - - //TimingManager.start("Block Fall"); - - for (int i = 0 ; i < 3 ; i++) + } + if (!UtilTime.elapsed(GetStateTime(), 120000L)) + { + return; + } + int d = 2; + if (!isAlready()) + { + Announce(C.cGreen + + C.Bold + + "As time passes, the world around you begins to crumble..."); + Player[] arrayOfPlayer; + int j = (arrayOfPlayer = UtilServer.getPlayers()).length; + for (int i = 0; i < j; i++) + { + Player player = arrayOfPlayer[i]; + + player.playSound(player.getLocation(), Sound.ENDERDRAGON_GROWL, + 3.0F, 1.0F); + } + setHasAlready(true); + } + if (UtilTime.elapsed(GetStateTime(), 180000L)) + { + d = 3; + } + if (UtilTime.elapsed(GetStateTime(), 240000L)) + { + d = 4; + } + for (int i = 0; i < d; i++) { Block bestBlock = null; - double bestDist = 0; - - for (Block block : _blocks) + double bestDist = 0.0D; + for (Block block : this._worldBlocks) { - double dist = UtilMath.offset2d(GetSpectatorLocation(), block.getLocation().add(0.5, 0.5, 0.5)); - - if (bestBlock == null || dist > bestDist) + double dist = UtilMath.offset2d(GetSpectatorLocation(), block + .getLocation().add(0.5D, 0.5D, 0.5D)); + if ((bestBlock == null) || (dist > bestDist)) { bestBlock = block; bestDist = dist; } } - - //Shuffle Down while (bestBlock.getRelative(BlockFace.DOWN).getType() != Material.AIR) - bestBlock = bestBlock.getRelative(BlockFace.DOWN); - - _blocks.remove(bestBlock); - + { + bestBlock = bestBlock.getRelative(BlockFace.DOWN); + } + this._worldBlocks.remove(bestBlock); if (bestBlock.getType() != Material.AIR) { - if (Math.random() > 0.75) - bestBlock.getWorld().spawnFallingBlock(bestBlock.getLocation().add(0.5, 0.5, 0.5), bestBlock.getType(), bestBlock.getData()); - - bestBlock.setType(Material.AIR); + if (Math.random() > 0.75D) + { + bestBlock.getWorld().spawnFallingBlock( + bestBlock.getLocation().add(0.5D, 0.5D, 0.5D), + bestBlock.getType(), bestBlock.getData()); + } + MapUtil.QuickChangeBlockAt(bestBlock.getLocation(), + Material.AIR); } } - - //TimingManager.stop("Block Fall"); } - + + @EventHandler + public void CreateRandomChests(GameStateChangeEvent event) + { + if (event.GetState() != Game.GameState.Recruit) + { + return; + } + HashSet ignore = new HashSet(); + + ignore.add(Material.LEAVES); + + int xDiff = this.WorldData.MaxX - this.WorldData.MinX; + int zDiff = this.WorldData.MaxZ - this.WorldData.MinZ; + + int done = 0; + while (done < 50) + { + Block block = UtilBlock.getHighest(this.WorldData.World, + this.WorldData.MinX + UtilMath.r(xDiff), + this.WorldData.MinZ + UtilMath.r(zDiff), ignore); + if ((UtilBlock.airFoliage(block)) + && (UtilBlock.solid(block.getRelative(BlockFace.DOWN)))) + { + block.setTypeIdAndData(Material.CHEST.getId(), + (byte) UtilMath.r(4), true); + done++; + this._worldBlocks.add(block); + } + } + } + + @EventHandler + public void OpenChest(PlayerInteractEvent event) + { + if (event.isCancelled()) + { + return; + } + Block block = event.getClickedBlock(); + if (block == null) + { + return; + } + if (!IsLive()) + { + return; + } + if (this._lootedBlocks.contains(block.getLocation())) + { + return; + } + BlockState state = block.getState(); + if ((state instanceof DoubleChest)) + { + DoubleChest doubleChest = (DoubleChest) state; + + fillChest(event.getPlayer(), + ((Chest) doubleChest.getLeftSide()).getBlock()); + fillChest(event.getPlayer(), + ((Chest) doubleChest.getRightSide()).getBlock()); + } + else if ((state instanceof Chest)) + { + fillChest(event.getPlayer(), block); + } + } + + @EventHandler + public void onTNTThrow(PlayerInteractEvent e) + { + if (!IsLive()) + { + return; + } + Player player = e.getPlayer(); + if (!UtilInv.IsItem(player.getItemInHand(), Material.TNT, (byte) 0)) + { + return; + } + e.setCancelled(true); + + UtilInv.remove(player, Material.TNT, (byte) 0, 1); + UtilInv.Update(player); + + TNTPrimed tnt = (TNTPrimed) player.getWorld().spawn( + player.getEyeLocation() + .add(player.getLocation().getDirection()), + TNTPrimed.class); + + tnt.setFuseTicks(60); + if (UtilEvent.isAction(e, UtilEvent.ActionType.L)) + { + UtilAction.velocity(tnt, player.getLocation().getDirection(), + 1.75D, false, 0.0D, 0.1D, 10.0D, false); + player.playSound(player.getLocation(), Sound.GHAST_FIREBALL, 3.0F, + 1.0F); + } + else if (UtilEvent.isAction(e, UtilEvent.ActionType.R)) + { + UtilAction.velocity(tnt, player.getLocation().getDirection(), + 0.55D, false, 0.0D, 0.1D, 10.0D, false); + } + } + + @EventHandler + public void ItemDespawn(ItemDespawnEvent event) + { + event.setCancelled(true); + } + + @EventHandler + public void pickupTNT(PlayerPickupItemEvent e) + { + ItemStack is = e.getItem().getItemStack(); + Player player = e.getPlayer(); + if (is.getType() == Material.TNT) + { + e.setCancelled(true); + this._tnt.Pickup(player, e.getItem()); + } + if (is.getType() == Material.CHEST) + { + e.setCancelled(true); + e.getItem().remove(); + } + } + + @EventHandler + public void handleTNTCannon(UpdateEvent e) + { + if (e.getType() != UpdateType.FAST) + { + return; + } + this._tnt.Update(); + } + + @EventHandler + public void cancelGeneratorExplosion(EntityExplodeEvent e) + { + for (Block block : e.blockList()) + { + if (block.getType() == Material.IRON_BLOCK) + { + e.blockList().remove(block); + } + if (block.getType() == Material.REDSTONE_BLOCK) + { + e.blockList().remove(block); + } + } + } + + @EventHandler + public void noZombieBurn(EntityCombustEvent e) + { + if ((e.getEntity() instanceof Zombie)) + { + e.setDuration(0); + e.setCancelled(true); + } + else + { + } + } + + @EventHandler + public void BlockBurn(BlockBurnEvent event) + { + event.setCancelled(true); + } + + @EventHandler + public void BlockDecay(LeavesDecayEvent event) + { + event.setCancelled(true); + } + + @EventHandler + public void BlockFade(BlockFadeEvent event) + { + event.setCancelled(true); + } + + @EventHandler + public void BlockSpread(BlockSpreadEvent event) + { + event.setCancelled(true); + } + + @EventHandler + public void PlayerKillAward(CombatDeathEvent event) + { + if (!(event.GetEvent().getEntity() instanceof Player)) + { + return; + } + Player player = (Player) event.GetEvent().getEntity(); + if (event.GetLog().GetKiller() == null) + { + return; + } + Player killer = UtilPlayer.searchExact(event.GetLog().GetKiller() + .GetName()); + if (killer == null) + { + return; + } + if (killer.equals(player)) + { + return; + } + killer.giveExpLevels(1); + } + + @EventHandler + public void blockBreak(BlockBreakEvent e) + { + if (e.getBlock().getType() == Material.IRON_BLOCK) + { + e.setCancelled(true); + } + if (e.getBlock().getType() == Material.REDSTONE_BLOCK) + { + e.setCancelled(true); + } + } + + private void fillChest(Player looter, Block block) + { + this._lootedBlocks.add(block.getLocation()); + Chest chest = (Chest) block.getState(); + + chest.getBlockInventory().clear(); + + int items = 2; + if (Math.random() > 0.5D) + { + items++; + } + if (Math.random() > 0.65D) + { + items++; + } + if (Math.random() > 0.8D) + { + items++; + } + if (Math.random() > 0.95D) + { + items++; + } + for (int i = 0; i < items; i++) + { + ItemStack item = this._baseLoot.getLoot(); + + chest.getBlockInventory().setItem(UtilMath.r(27), item); + } + } + + private void setupLoot() + { + this._baseLoot.addLoot(new RandomItem(Material.BAKED_POTATO, 30, 1, 3)); + this._baseLoot.addLoot(new RandomItem(Material.COOKED_BEEF, 30, 1, 2)); + this._baseLoot + .addLoot(new RandomItem(Material.COOKED_CHICKEN, 30, 1, 2)); + this._baseLoot.addLoot(new RandomItem(Material.CARROT_ITEM, 30, 1, 3)); + this._baseLoot + .addLoot(new RandomItem(Material.MUSHROOM_SOUP, 15, 1, 1)); + this._baseLoot.addLoot(new RandomItem(Material.WHEAT, 30, 1, 6)); + this._baseLoot.addLoot(new RandomItem(Material.APPLE, 30, 1, 4)); + this._baseLoot.addLoot(new RandomItem(Material.PORK, 30, 1, 4)); + this._baseLoot.addLoot(new RandomItem(Material.ROTTEN_FLESH, 40, 1, 6)); + + this._baseLoot.addLoot(new RandomItem(Material.WOOD_AXE, 60)); + this._baseLoot.addLoot(new RandomItem(Material.WOOD_PICKAXE, 60)); + this._baseLoot.addLoot(new RandomItem(Material.WOOD_SPADE, 30)); + this._baseLoot.addLoot(new RandomItem(Material.WOOD_SWORD, 55)); + this._baseLoot.addLoot(new RandomItem(Material.STONE_AXE, 25)); + this._baseLoot.addLoot(new RandomItem(Material.STONE_PICKAXE, 45)); + this._baseLoot.addLoot(new RandomItem(Material.STONE_SPADE, 25)); + this._baseLoot.addLoot(new RandomItem(Material.STONE_SWORD, 20)); + this._baseLoot.addLoot(new RandomItem(Material.IRON_SWORD, 10)); + this._baseLoot.addLoot(new RandomItem(Material.DIAMOND_SWORD, 3)); + + this._baseLoot.addLoot(new RandomItem(Material.LEATHER_BOOTS, 20)); + this._baseLoot.addLoot(new RandomItem(Material.LEATHER_CHESTPLATE, 20)); + this._baseLoot.addLoot(new RandomItem(Material.LEATHER_HELMET, 20)); + this._baseLoot.addLoot(new RandomItem(Material.LEATHER_LEGGINGS, 20)); + + this._baseLoot.addLoot(new RandomItem(Material.GOLD_BOOTS, 20)); + this._baseLoot.addLoot(new RandomItem(Material.GOLD_CHESTPLATE, 17)); + this._baseLoot.addLoot(new RandomItem(Material.GOLD_HELMET, 19)); + this._baseLoot.addLoot(new RandomItem(Material.GOLD_LEGGINGS, 20)); + + this._baseLoot.addLoot(new RandomItem(Material.IRON_BOOTS, 7)); + this._baseLoot.addLoot(new RandomItem(Material.IRON_CHESTPLATE, 5)); + this._baseLoot.addLoot(new RandomItem(Material.IRON_HELMET, 8)); + this._baseLoot.addLoot(new RandomItem(Material.IRON_LEGGINGS, 6)); + + this._baseLoot.addLoot(new RandomItem(Material.BOW, 17)); + this._baseLoot.addLoot(new RandomItem(Material.ARROW, 18, 1, 3)); + this._baseLoot.addLoot(new RandomItem(Material.SNOW_BALL, 30, 1, 2)); + this._baseLoot.addLoot(new RandomItem(Material.EGG, 30, 1, 2)); + this._baseLoot.addLoot(new RandomItem(Material.EXP_BOTTLE, 30, 1, 2)); + } + + public boolean isAlready() + { + return this._already; + } + + public boolean setHasAlready(boolean _already) + { + this._already = _already; + return _already; + } }