From 72b9c7dececd64c2d408190ab6e209a2a306f8c5 Mon Sep 17 00:00:00 2001 From: Jottyfan Date: Sat, 15 Jun 2024 14:45:22 +0200 Subject: [PATCH] fixed recipes, working tools --- .classpath | 613 +++++++++++++++++- .project | 27 +- .settings/org.eclipse.jdt.core.prefs | 2 +- gradle.properties | 2 +- .../de/jottyfan/quickiemod/QuickieMod.java | 1 + .../jottyfan/quickiemod/api/Neighborhood.java | 84 +++ .../quickiemod/api/NeighborhoodBean.java | 77 +++ .../blocks/BlockOreDeepslateSulphor.java | 4 +- .../blocks/BlockOreNetherSulphor.java | 4 +- .../quickiemod/blocks/BlockOreSalpeter.java | 4 +- .../blocks/BlockOreSandSalpeter.java | 4 +- .../quickiemod/blocks/BlockOreSulphor.java | 4 +- .../quickiemod/blocks/BlockSalpeter.java | 4 +- .../quickiemod/blocks/BlockSandSalpeter.java | 4 +- .../quickiemod/blocks/BlockSulphor.java | 4 +- .../quickiemod/event/BreakBlockCallback.java | 29 + .../quickiemod/event/EventBlockBreak.java | 193 ++++++ .../quickiemod/init/RegistryManager.java | 15 +- .../quickiemod/items/HarvestRange.java | 101 +++ .../quickiemod/items/QuickieItems.java | 24 +- .../items/ToolQuickiepowderAxe.java | 26 + .../items/ToolQuickiepowderHoe.java | 20 + .../items/ToolQuickiepowderPickaxe.java | 54 ++ .../items/ToolQuickiepowderShovel.java | 97 +++ .../items/ToolQuickiepowderWaterHoe.java | 38 ++ .../quickiemod/items/ToolRangeable.java | 38 ++ .../quickiemod/items/ToolRangeableAxe.java | 63 ++ .../quickiemod/items/ToolRangeableHoe.java | 97 +++ .../quickiemod/items/ToolSpeedpowderAxe.java | 26 + .../quickiemod/items/ToolSpeedpowderHoe.java | 20 + .../items/ToolSpeedpowderPickaxe.java | 55 ++ .../items/ToolSpeedpowderShears.java | 96 +++ .../items/ToolSpeedpowderShovel.java | 96 +++ .../items/ToolSpeedpowderWaterHoe.java | 38 ++ .../items/mat/QuickieToolMaterial.java | 64 ++ .../quickiemod/mixin/BlockBreakMixin.java | 33 + .../models/item/quickiepowderaxe.json | 6 + .../models/item/quickiepowderhoe.json | 6 + .../models/item/quickiepowderpickaxe.json | 6 + .../models/item/quickiepowdershovel.json | 6 + .../models/item/quickiepowderwaterhoe.json | 6 + .../models/item/speedpowderaxe.json | 6 + .../models/item/speedpowderhoe.json | 6 + .../models/item/speedpowderpickaxe.json | 6 + .../models/item/speedpowdershovel.json | 6 + .../models/item/speedpowderwaterhoe.json | 6 + .../textures/item/quickiepowderaxe.png | Bin 0 -> 4411 bytes .../textures/item/quickiepowderhoe.png | Bin 0 -> 4382 bytes .../textures/item/quickiepowderpickaxe.png | Bin 0 -> 4404 bytes .../textures/item/quickiepowdershovel.png | Bin 0 -> 4404 bytes .../textures/item/quickiepowderwaterhoe.png | Bin 0 -> 4436 bytes .../textures/item/speedpowderaxe.png | Bin 0 -> 4399 bytes .../textures/item/speedpowderhoe.png | Bin 0 -> 6016 bytes .../textures/item/speedpowderpickaxe.png | Bin 0 -> 4409 bytes .../textures/item/speedpowdershovel.png | Bin 0 -> 4417 bytes .../textures/item/speedpowderwaterhoe.png | Bin 0 -> 6140 bytes src/main/resources/data/c/tags/item/axes.json | 7 + src/main/resources/data/c/tags/item/hoes.json | 9 + .../resources/data/c/tags/item/pickaxes.json | 7 + .../resources/data/c/tags/item/shovels.json | 7 + .../{blocks => block}/mineable/pickaxe.json | 0 .../blasting_oxidized_copper_powder1.json | 0 .../blasting_oxidized_copper_powder2.json | 0 .../blasting_oxidized_copper_powder3.json | 0 .../blasting_oxidized_copper_powder4.json | 0 .../blasting_quickieingot.json | 0 .../blasting_salpeter_from_brain_coral.json | 0 .../blasting_salpeter_from_bubble_coral.json | 0 .../blasting_salpeter_from_fire_coral.json | 0 .../blasting_salpeter_from_horn_coral.json | 0 .../blasting_salpeter_from_tube_coral.json | 0 .../blasting_speedingot.json | 0 .../campfire_dried_kelpblock.json | 0 .../{recipes => recipe}/campfire_torch.json | 0 ...blockquickiepowder_from_quickiepowder.json | 0 .../shaped_blocksalpeter.json | 0 ...ped_blockspeedpowder_from_speedpowder.json | 0 .../shaped_blocksulphor.json | 0 .../shaped_canolabottlestack.json | 0 .../shaped_carrotstack_from_carrots.json | 0 .../{recipes => recipe}/shaped_drill.json | 0 .../{recipes => recipe}/shaped_drillstop.json | 0 .../shaped_emptylavahoarder.json | 0 .../shaped_itemhoarder_from_barrel.json | 0 .../shaped_itemhoarder_from_chest.json | 0 .../shaped_kelpstack_from_kelp.json | 0 .../shaped_monsterhoarder.json | 0 .../recipe/shaped_quickiepowderaxe.json | 21 + .../recipe/shaped_quickiepowderhoe.json | 21 + .../recipe/shaped_quickiepowderpickaxe.json | 21 + .../recipe/shaped_quickiepowdershovel.json | 21 + .../shaped_speedpowder_shears.json | 0 .../recipe/shaped_speedpowderaxe.json | 21 + .../recipe/shaped_speedpowderhoe.json | 21 + .../recipe/shaped_speedpowderpickaxe.json | 21 + .../recipe/shaped_speedpowdershovel.json | 21 + .../shaped_string_from_cotton.json | 0 ...er_from_slimeblockandspeedpowderblock.json | 0 ...edpowder_from_salpetersulforcoalblock.json | 0 .../shapeless_canolabottle.json | 0 .../shapeless_canolabottle_from_stack.json | 0 .../shapeless_carrots_from_carrotstack.json | 0 .../shapeless_drill_fromdrillnorth.json | 0 .../shapeless_drilleast_fromdrill.json | 0 .../shapeless_drillnorth_fromdrillwest.json | 0 .../shapeless_drillsouth_fromdrilleast.json | 0 .../shapeless_drillwest_fromdrillsouth.json | 0 .../shapeless_glowstone_item_frame.json | 0 .../recipe/shapeless_gunpowder.json | 18 + .../shapeless_quickiepowder_from_block.json | 0 ...ickiepowder_from_oxidizedcopperpowder.json | 0 ...hapeless_quickiepowder_from_slimeball.json | 0 .../shapeless_quickiepowderwaterhoe.json | 15 + .../shapeless_salpeter_from_block.json | 0 .../shapeless_speedpowder.json | 0 .../shapeless_speedpowder_from_block.json | 0 .../recipe/shapeless_speedpowderwaterhoe.json | 15 + .../shapeless_string_from_wool.json | 0 .../{recipes => recipe}/shapeless_stub.json | 0 .../shapeless_sulphor_from_block.json | 0 .../smelting_salpeter1.json | 0 .../smelting_salpeter2.json | 0 .../smelting_salpeter3.json | 0 .../smelting_salpeter4.json | 0 .../{recipes => recipe}/smelting_sulfur1.json | 0 .../{recipes => recipe}/smelting_sulfur2.json | 0 .../smoking_dried_kelpblock.json | 0 .../smoking_leather_from_flesh_stripes.json | 0 .../stonecutting_flesh_stripes.json | 0 .../tags/block/mineable/pickaxe.json | 12 + .../worldgen/placed_feature/blocksulphor.json | 3 + .../worldgen/placed_feature/dirtsalpeter.json | 3 + .../placed_feature/oredeepslatesulphor.json | 3 + .../placed_feature/orenethersulphor.json | 3 + .../worldgen/placed_feature/oresalpeter.json | 3 + .../placed_feature/oresandsalpeter.json | 3 + .../worldgen/placed_feature/oresulphor.json | 3 + .../worldgen/placed_feature/sandsalpeter.json | 3 + src/main/resources/fabric.mod.json | 3 + src/main/resources/quickiemod.mixins.json | 14 + 140 files changed, 2377 insertions(+), 43 deletions(-) create mode 100644 src/main/java/de/jottyfan/quickiemod/api/Neighborhood.java create mode 100644 src/main/java/de/jottyfan/quickiemod/api/NeighborhoodBean.java create mode 100644 src/main/java/de/jottyfan/quickiemod/event/BreakBlockCallback.java create mode 100644 src/main/java/de/jottyfan/quickiemod/event/EventBlockBreak.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/HarvestRange.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderAxe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderHoe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderPickaxe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderShovel.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderWaterHoe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolRangeable.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolRangeableAxe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolRangeableHoe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderAxe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderHoe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderPickaxe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShears.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShovel.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderWaterHoe.java create mode 100644 src/main/java/de/jottyfan/quickiemod/items/mat/QuickieToolMaterial.java create mode 100644 src/main/java/de/jottyfan/quickiemod/mixin/BlockBreakMixin.java create mode 100644 src/main/resources/assets/quickiemod/models/item/quickiepowderaxe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/quickiepowderhoe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/quickiepowderpickaxe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/quickiepowdershovel.json create mode 100644 src/main/resources/assets/quickiemod/models/item/quickiepowderwaterhoe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/speedpowderaxe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/speedpowderhoe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/speedpowderpickaxe.json create mode 100644 src/main/resources/assets/quickiemod/models/item/speedpowdershovel.json create mode 100644 src/main/resources/assets/quickiemod/models/item/speedpowderwaterhoe.json create mode 100644 src/main/resources/assets/quickiemod/textures/item/quickiepowderaxe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/quickiepowderhoe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/quickiepowderpickaxe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/quickiepowdershovel.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/quickiepowderwaterhoe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/speedpowderaxe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/speedpowderhoe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/speedpowderpickaxe.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/speedpowdershovel.png create mode 100644 src/main/resources/assets/quickiemod/textures/item/speedpowderwaterhoe.png create mode 100644 src/main/resources/data/c/tags/item/axes.json create mode 100644 src/main/resources/data/c/tags/item/hoes.json create mode 100644 src/main/resources/data/c/tags/item/pickaxes.json create mode 100644 src/main/resources/data/c/tags/item/shovels.json rename src/main/resources/data/minecraft/tags/{blocks => block}/mineable/pickaxe.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_oxidized_copper_powder1.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_oxidized_copper_powder2.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_oxidized_copper_powder3.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_oxidized_copper_powder4.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_quickieingot.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_salpeter_from_brain_coral.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_salpeter_from_bubble_coral.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_salpeter_from_fire_coral.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_salpeter_from_horn_coral.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_salpeter_from_tube_coral.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/blasting_speedingot.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/campfire_dried_kelpblock.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/campfire_torch.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_blockquickiepowder_from_quickiepowder.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_blocksalpeter.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_blockspeedpowder_from_speedpowder.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_blocksulphor.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_canolabottlestack.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_carrotstack_from_carrots.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_drill.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_drillstop.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_emptylavahoarder.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_itemhoarder_from_barrel.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_itemhoarder_from_chest.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_kelpstack_from_kelp.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_monsterhoarder.json (100%) create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_quickiepowderaxe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_quickiepowderhoe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_quickiepowderpickaxe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_quickiepowdershovel.json rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_speedpowder_shears.json (100%) create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_speedpowderaxe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_speedpowderhoe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_speedpowderpickaxe.json create mode 100644 src/main/resources/data/quickiemod/recipe/shaped_speedpowdershovel.json rename src/main/resources/data/quickiemod/{recipes => recipe}/shaped_string_from_cotton.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_blockquickiepowder_from_slimeblockandspeedpowderblock.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_blockspeedpowder_from_salpetersulforcoalblock.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_canolabottle.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_canolabottle_from_stack.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_carrots_from_carrotstack.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_drill_fromdrillnorth.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_drilleast_fromdrill.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_drillnorth_fromdrillwest.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_drillsouth_fromdrilleast.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_drillwest_fromdrillsouth.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_glowstone_item_frame.json (100%) create mode 100644 src/main/resources/data/quickiemod/recipe/shapeless_gunpowder.json rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_quickiepowder_from_block.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_quickiepowder_from_oxidizedcopperpowder.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_quickiepowder_from_slimeball.json (100%) create mode 100644 src/main/resources/data/quickiemod/recipe/shapeless_quickiepowderwaterhoe.json rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_salpeter_from_block.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_speedpowder.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_speedpowder_from_block.json (100%) create mode 100644 src/main/resources/data/quickiemod/recipe/shapeless_speedpowderwaterhoe.json rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_string_from_wool.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_stub.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/shapeless_sulphor_from_block.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_salpeter1.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_salpeter2.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_salpeter3.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_salpeter4.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_sulfur1.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smelting_sulfur2.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smoking_dried_kelpblock.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/smoking_leather_from_flesh_stripes.json (100%) rename src/main/resources/data/quickiemod/{recipes => recipe}/stonecutting_flesh_stripes.json (100%) create mode 100644 src/main/resources/data/quickiemod/tags/block/mineable/pickaxe.json create mode 100644 src/main/resources/quickiemod.mixins.json diff --git a/.classpath b/.classpath index be88c88..22fc6b2 100644 --- a/.classpath +++ b/.classpath @@ -1,5 +1,6 @@ + @@ -12,7 +13,615 @@ - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/.project b/.project index 6b24044..a1b1dc8 100644 --- a/.project +++ b/.project @@ -2,22 +2,21 @@ quickiemod - - - - - org.eclipse.jdt.core.javabuilder - - - - - org.eclipse.buildship.core.gradleprojectbuilder - - - - + org.eclipse.jdt.core.javanature org.eclipse.buildship.core.gradleprojectnature + + + org.eclipse.jdt.core.javabuilder + + + + org.eclipse.buildship.core.gradleprojectbuilder + + + + + diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs index 06d2104..f3eb3df 100644 --- a/.settings/org.eclipse.jdt.core.prefs +++ b/.settings/org.eclipse.jdt.core.prefs @@ -1,5 +1,5 @@ # -#Sat Jun 01 10:37:20 CEST 2024 +#Sat Jun 15 13:57:14 CEST 2024 eclipse.preferences.version=1 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled org.eclipse.jdt.core.compiler.codegen.targetPlatform=21 diff --git a/gradle.properties b/gradle.properties index 427b7ae..45528df 100644 --- a/gradle.properties +++ b/gradle.properties @@ -9,7 +9,7 @@ yarn_mappings=1.21+build.2 loader_version=0.15.11 # Mod Properties -mod_version=1.21.0.0 +mod_version=1.21.0.1 maven_group=de.jottyfan.quickiemod archives_base_name=quickiemod diff --git a/src/main/java/de/jottyfan/quickiemod/QuickieMod.java b/src/main/java/de/jottyfan/quickiemod/QuickieMod.java index a9f6fc5..4761c84 100644 --- a/src/main/java/de/jottyfan/quickiemod/QuickieMod.java +++ b/src/main/java/de/jottyfan/quickiemod/QuickieMod.java @@ -21,6 +21,7 @@ public class QuickieMod implements ModInitializer { LOGGER.info("loading {}", MODID); RegistryManager.registerBlockEntityTypes(); RegistryManager.registerItems(); + RegistryManager.registerEvents(); RegistryManager.registerBlocks(); RegistryManager.registerFeatures(); RegistryManager.registerItemGroup(); diff --git a/src/main/java/de/jottyfan/quickiemod/api/Neighborhood.java b/src/main/java/de/jottyfan/quickiemod/api/Neighborhood.java new file mode 100644 index 0000000..eea245a --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/api/Neighborhood.java @@ -0,0 +1,84 @@ +package de.jottyfan.quickiemod.api; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import java.util.function.BiFunction; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class Neighborhood { + + /** + * find the same blocks that is next to the current position pos + * + * @param world the world to look for the blocks + * @param pos the starting position + * @param seekLimit the limit of seek operations + * @param checkLambda check functionality + * @return a set of found block positions + */ + public static final Set findEqualBlock(World world, BlockPos pos, int seekLimit, + BiFunction checkLambda) { + Set found = new HashSet<>(); + found.add(new NeighborhoodBean(pos, true)); + + while (pos != null && found.size() < seekLimit) { + findNewNeihgbor(world, pos.east(), found, checkLambda); + findNewNeihgbor(world, pos.south(), found, checkLambda); + findNewNeihgbor(world, pos.west(), found, checkLambda); + findNewNeihgbor(world, pos.north(), found, checkLambda); + pos = findNextUncheckedField(found); + } + + Set finals = new HashSet<>(); + for (NeighborhoodBean bean : found) { + finals.add(bean.getPos()); + } + return finals; + } + + private static final BlockPos findNextUncheckedField(Set found) { + Iterator i = found.iterator(); + while (i.hasNext()) { + NeighborhoodBean bean = i.next(); + if (!bean.isChecked()) { + bean.setChecked(true); + return bean.getPos(); + } + } + return null; + } + + /** + * find new neighbor at pos + * + * @param world the world + * @param pos the position + * @param found the set with all already found positions + * @return true or false + */ + private static final boolean findNewNeihgbor(World world, BlockPos pos, Set found, + BiFunction checkLambda) { + NeighborhoodBean bean = new NeighborhoodBean(pos); + if (found.contains(bean) || found.contains(bean.over()) || found.contains(bean.below())) { + return false; + } else if (checkLambda.apply(world, pos).booleanValue()) { + found.add(bean); + return true; + } else if (checkLambda.apply(world, pos.up()).booleanValue()) { + found.add(new NeighborhoodBean(pos.up())); + return true; + } else if (checkLambda.apply(world, pos.down()).booleanValue()) { + found.add(new NeighborhoodBean(pos.down())); + return true; + } + return false; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/api/NeighborhoodBean.java b/src/main/java/de/jottyfan/quickiemod/api/NeighborhoodBean.java new file mode 100644 index 0000000..0acf23a --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/api/NeighborhoodBean.java @@ -0,0 +1,77 @@ +package de.jottyfan.quickiemod.api; + +import java.util.Objects; + +import net.minecraft.util.math.BlockPos; + +/** + * + * @author jotty + * + */ +public class NeighborhoodBean { + private final BlockPos pos; + private boolean checked; + + public NeighborhoodBean(BlockPos pos, boolean checked) { + super(); + this.pos = pos; + this.checked = checked; + } + + public NeighborhoodBean(BlockPos pos) { + super(); + this.pos = pos; + this.checked = false; + } + + public NeighborhoodBean over() { + return new NeighborhoodBean(pos.up(), checked); + } + + public NeighborhoodBean below() { + return new NeighborhoodBean(pos.down(), checked); + } + + @Override + public int hashCode() { + return Objects.hash(pos); + } + + @Override + public boolean equals(Object obj) { + Boolean result = null; + if (this == obj) { + result = true; + } else if (obj == null) { + result = false; + } else if (getClass() != obj.getClass()) { + result = false; + } else { + NeighborhoodBean other = (NeighborhoodBean) obj; + result = Objects.equals(pos, other.pos); + } + return result; + } + + /** + * @return the checked + */ + public boolean isChecked() { + return checked; + } + + /** + * @param checked the checked to set + */ + public void setChecked(boolean checked) { + this.checked = checked; + } + + /** + * @return the pos + */ + public BlockPos getPos() { + return pos; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreDeepslateSulphor.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreDeepslateSulphor.java index fad79b6..77bf6cd 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreDeepslateSulphor.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreDeepslateSulphor.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; /** @@ -20,7 +20,7 @@ import net.minecraft.loot.context.LootContextParameterSet.Builder; public class BlockOreDeepslateSulphor extends ExperienceDroppingBlock { public BlockOreDeepslateSulphor() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(1.9f).requiresTool()); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(1.9f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreNetherSulphor.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreNetherSulphor.java index 8350eae..8a5da41 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreNetherSulphor.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreNetherSulphor.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; /** * @@ -19,7 +19,7 @@ import net.minecraft.loot.context.LootContextParameterSet.Builder; public class BlockOreNetherSulphor extends ExperienceDroppingBlock { public BlockOreNetherSulphor() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(2.1f).requiresTool()); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(2.1f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSalpeter.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSalpeter.java index 3c5d085..ff5f183 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSalpeter.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSalpeter.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; import net.minecraft.util.math.random.Random; /** @@ -20,7 +20,7 @@ import net.minecraft.util.math.random.Random; public class BlockOreSalpeter extends ExperienceDroppingBlock { public BlockOreSalpeter() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(3.1f).requiresTool()); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(3.1f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSandSalpeter.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSandSalpeter.java index 6f40080..fe9432b 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSandSalpeter.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSandSalpeter.java @@ -5,12 +5,12 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; import net.minecraft.util.math.random.Random; /** @@ -21,7 +21,7 @@ import net.minecraft.util.math.random.Random; public class BlockOreSandSalpeter extends ExperienceDroppingBlock { public BlockOreSandSalpeter() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(2.9f).requiresTool()); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(2.9f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSulphor.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSulphor.java index e1d22f4..b6c8930 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSulphor.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockOreSulphor.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; /** @@ -20,7 +20,7 @@ import net.minecraft.loot.context.LootContextParameterSet.Builder; public class BlockOreSulphor extends ExperienceDroppingBlock { public BlockOreSulphor() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(1.9f).requiresTool()); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(1.9f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSalpeter.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSalpeter.java index 9a4426a..daf245d 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSalpeter.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSalpeter.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; /** * @@ -19,7 +19,7 @@ import net.minecraft.loot.context.LootContextParameterSet.Builder; public class BlockSalpeter extends ExperienceDroppingBlock { public BlockSalpeter() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(0.5f)); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(0.5f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSandSalpeter.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSandSalpeter.java index 35c8be4..50bc957 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSandSalpeter.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSandSalpeter.java @@ -6,12 +6,12 @@ import java.util.List; import com.mojang.serialization.MapCodec; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.block.FallingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; import net.minecraft.util.math.random.Random; /** @@ -22,7 +22,7 @@ import net.minecraft.util.math.random.Random; public class BlockSandSalpeter extends FallingBlock { public BlockSandSalpeter() { - super(AbstractBlock.Settings.create().hardness(3.1f).requiresTool()); + super(Settings.create().strength(2.5f).hardness(3.1f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSulphor.java b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSulphor.java index 5769b06..cfe8dd0 100644 --- a/src/main/java/de/jottyfan/quickiemod/blocks/BlockSulphor.java +++ b/src/main/java/de/jottyfan/quickiemod/blocks/BlockSulphor.java @@ -5,11 +5,11 @@ import java.util.List; import de.jottyfan.quickiemod.blocks.help.IntProviderHelper; import de.jottyfan.quickiemod.items.QuickieItems; -import net.minecraft.block.AbstractBlock; import net.minecraft.block.BlockState; import net.minecraft.block.ExperienceDroppingBlock; import net.minecraft.item.ItemStack; import net.minecraft.loot.context.LootContextParameterSet.Builder; +import net.minecraft.sound.BlockSoundGroup; /** * @@ -19,7 +19,7 @@ import net.minecraft.loot.context.LootContextParameterSet.Builder; public class BlockSulphor extends ExperienceDroppingBlock { public BlockSulphor() { - super(IntProviderHelper.of(0, 2), AbstractBlock.Settings.create().hardness(0.5f)); + super(IntProviderHelper.of(0, 2), Settings.create().strength(2.5f).hardness(0.5f).sounds(BlockSoundGroup.SOUL_SAND).requiresTool()); } @Override diff --git a/src/main/java/de/jottyfan/quickiemod/event/BreakBlockCallback.java b/src/main/java/de/jottyfan/quickiemod/event/BreakBlockCallback.java new file mode 100644 index 0000000..b1ab672 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/event/BreakBlockCallback.java @@ -0,0 +1,29 @@ +package de.jottyfan.quickiemod.event; + +import net.fabricmc.fabric.api.event.Event; +import net.fabricmc.fabric.api.event.EventFactory; +import net.minecraft.block.BlockState; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.util.ActionResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public interface BreakBlockCallback { + Event EVENT = EventFactory.createArrayBacked(BreakBlockCallback.class, + (listeners) -> (world, blockPos, blockState, playerEntity) -> { + for (BreakBlockCallback listener : listeners) { + ActionResult result = listener.injectBlockBreakCallback(world, blockPos, blockState, playerEntity); + if (result != ActionResult.PASS) { + return result; + } + } + return ActionResult.PASS; + }); + + ActionResult injectBlockBreakCallback(World world, BlockPos blockPos, BlockState blockState, PlayerEntity playerEntity); +} diff --git a/src/main/java/de/jottyfan/quickiemod/event/EventBlockBreak.java b/src/main/java/de/jottyfan/quickiemod/event/EventBlockBreak.java new file mode 100644 index 0000000..7e790c4 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/event/EventBlockBreak.java @@ -0,0 +1,193 @@ +package de.jottyfan.quickiemod.event; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import de.jottyfan.quickiemod.QuickieMod; +import de.jottyfan.quickiemod.items.HarvestRange; +import de.jottyfan.quickiemod.items.QuickieItems; +import de.jottyfan.quickiemod.items.ToolRangeable; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.entity.EquipmentSlot; +import net.minecraft.entity.ExperienceOrbEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class EventBlockBreak { + private static final Logger LOGGER = LogManager.getLogger(QuickieMod.MODID); + + private enum BlockBreakDirection { + UPWARDS, ALL; + } + + public void doBreakBlock(World world, BlockPos blockPos, BlockState blockState, PlayerEntity playerEntity) { + ItemStack mainHandItemStack = playerEntity.getEquippedStack(EquipmentSlot.MAINHAND); + if (mainHandItemStack != null) { + Item item = mainHandItemStack.getItem(); + if (item instanceof ToolRangeable) { + ToolRangeable tool = (ToolRangeable) item; + Block block = blockState.getBlock(); + int handled = handleRangeableTools(tool, mainHandItemStack, world, block, blockPos, playerEntity); + if (handled >= 255) { + // reward for using rangeable tool very successful + world.spawnEntity( + new ExperienceOrbEntity(world, blockPos.getX(), blockPos.getY(), blockPos.getZ(), handled / 255)); + } + } + } + } + + /** + * handle the rangeable tools break event + * + * @param tool the tool that has been used + * @param itemStack the item stack + * @param world the world + * @param block the block to break + * @param pos the position of the current block + * @param player the current player + * @return number of affected blocks + */ + private int handleRangeableTools(ToolRangeable tool, ItemStack itemStack, World world, Block currentBlock, + BlockPos pos, PlayerEntity player) { + List validBlocks = tool.getBlockList(currentBlock); + HarvestRange range = tool.getRange(itemStack); + + LOGGER.info("current tool: {}", tool); + + if (QuickieItems.SPEEDPOWDERAXE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.UPWARDS, + player, true); + } else if (QuickieItems.SPEEDPOWDERPICKAXE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else if (QuickieItems.SPEEDPOWDERSHOVEL.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else if (QuickieItems.SPEEDPOWDERHOE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else if (QuickieItems.QUICKIEPOWDERAXE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.UPWARDS, + player, true); + } else if (QuickieItems.QUICKIEPOWDERPICKAXE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else if (QuickieItems.QUICKIEPOWDERSHOVEL.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else if (QuickieItems.QUICKIEPOWDERHOE.getItem().equals(tool)) { + return breakBlockRecursive(new ArrayList<>(), world, validBlocks, pos, tool, range, BlockBreakDirection.ALL, + player, false); + } else { + return 0; + } + } + + /** + * break block recursively; + * + * @param visitedBlocks the positions of visited blocks + * @param world the world + * @param validBlocks the blocks to break + * @param tool the tool used + * @param range the range left over + * @param pos the position + * @param blockBreakDirection the direction for the recursive call + * @param player the player + * @return number of affected blocks + */ + private int breakBlockRecursive(List visitedBlocks, World world, List validBlocks, BlockPos pos, + ToolRangeable tool, HarvestRange range, BlockBreakDirection blockBreakDirection, PlayerEntity player, + boolean breakLeaves) { + if (visitedBlocks.contains(pos.toString())) { + return 0; + } else if (validBlocks == null) { + return 0; + } else { + visitedBlocks.add(pos.toString()); + } + Integer affected = 0; + BlockState blockState = world.getBlockState(pos); + if (tool.canBreakNeighbors(blockState)) { + Block currentBlock = blockState.getBlock(); + if (validBlocks.contains(currentBlock)) { + Block.dropStacks(blockState, world, pos); // includes xorbs + affected += 1; + world.setBlockState(pos, Blocks.AIR.getDefaultState()); + if (range == null || range.getxRange() > 1 || range.getyRange() > 1 || range.getzRange() > 1) { + HarvestRange nextRadius = range == null ? null : range.addXYZ(-1); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.north(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.north().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.north().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.south(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.south().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.south().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().north(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().north().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().north().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().south().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().south().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.up().south(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + + if (BlockBreakDirection.ALL.equals(blockBreakDirection)) { + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().north(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().south(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().east(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().west(), tool, nextRadius, + blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().north().east(), tool, + nextRadius, blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().north().west(), tool, + nextRadius, blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().south().east(), tool, + nextRadius, blockBreakDirection, player, breakLeaves); + affected += breakBlockRecursive(visitedBlocks, world, validBlocks, pos.down().south().west(), tool, + nextRadius, blockBreakDirection, player, breakLeaves); + } + } + } + } + return affected; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/init/RegistryManager.java b/src/main/java/de/jottyfan/quickiemod/init/RegistryManager.java index 630455a..c13c900 100644 --- a/src/main/java/de/jottyfan/quickiemod/init/RegistryManager.java +++ b/src/main/java/de/jottyfan/quickiemod/init/RegistryManager.java @@ -6,6 +6,8 @@ import org.slf4j.LoggerFactory; import de.jottyfan.quickiemod.QuickieMod; import de.jottyfan.quickiemod.blockentity.BlockEntityTypes; import de.jottyfan.quickiemod.blocks.QuickieBlocks; +import de.jottyfan.quickiemod.event.BreakBlockCallback; +import de.jottyfan.quickiemod.event.EventBlockBreak; import de.jottyfan.quickiemod.items.QuickieItems; import net.fabricmc.fabric.api.biome.v1.BiomeModifications; import net.fabricmc.fabric.api.biome.v1.BiomeSelectors; @@ -21,6 +23,7 @@ import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKey; import net.minecraft.registry.RegistryKeys; import net.minecraft.text.Text; +import net.minecraft.util.ActionResult; import net.minecraft.util.Identifier; /** @@ -47,7 +50,7 @@ public class RegistryManager { } public static final void registerItems() { - LOGGER.debug("registering items"); + LOGGER.info("registering items"); for (QuickieItems i : QuickieItems.values()) { Registry.register(Registries.ITEM, Identifier.of(QuickieMod.MODID, i.getName()), i.getItem()); } @@ -60,7 +63,7 @@ public class RegistryManager { } public static final void registerBlocks() { - LOGGER.debug("registering blocks"); + LOGGER.info("registering blocks"); for (QuickieBlocks b : QuickieBlocks.values()) { Registry.register(Registries.BLOCK, Identifier.of(QuickieMod.MODID, b.getName()), b.getBlock()); Registry.register(Registries.ITEM, Identifier.of(QuickieMod.MODID, b.getName()), new BlockItem(b.getBlock(), new Settings())); @@ -77,6 +80,14 @@ public class RegistryManager { FeaturesManager.netherOres()); } + public static final void registerEvents() { + LOGGER.info("registering events"); + BreakBlockCallback.EVENT.register((world, blockPos, blockState, playerEntity) -> { + new EventBlockBreak().doBreakBlock(world, blockPos, blockState, playerEntity); + return ActionResult.SUCCESS; + }); + } + public static final void registerBlockEntityTypes() { new BlockEntityTypes(); } diff --git a/src/main/java/de/jottyfan/quickiemod/items/HarvestRange.java b/src/main/java/de/jottyfan/quickiemod/items/HarvestRange.java new file mode 100644 index 0000000..4e5efc3 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/HarvestRange.java @@ -0,0 +1,101 @@ +package de.jottyfan.quickiemod.items; + +import java.io.Serializable; + +/** + * + * @author jotty + * + */ +public class HarvestRange implements Serializable { + private static final long serialVersionUID = 1L; + private int xRange; + private int yRange; + private int zRange; + + public HarvestRange(int xyzRange) { + super(); + this.xRange = xyzRange; + this.yRange = xyzRange; + this.zRange = xyzRange; + } + + public HarvestRange(int[] xyzRange) { + super(); + this.xRange = xyzRange[0]; + this.yRange = xyzRange[1]; + this.zRange = xyzRange[2]; + } + + public HarvestRange(int xRange, int yRange, int zRange) { + super(); + this.xRange = xRange; + this.yRange = yRange; + this.zRange = zRange; + } + + /** + * add i to x, y and z and return the resulting class as a new one + * + * @param i + * the summand + * @return the new class + */ + public HarvestRange addXYZ(int i) { + return new HarvestRange(xRange + i, yRange + i, zRange + i); + } + + /** + * get range as int array + * + * @return the int array + */ + public int[] getRangeAsArray() { + return new int[] {xRange, yRange, zRange}; + } + + /** + * @return the xRange + */ + public int getxRange() { + return xRange; + } + + /** + * @param xRange + * the xRange to set + */ + public void setxRange(int xRange) { + this.xRange = xRange; + } + + /** + * @return the yRange + */ + public int getyRange() { + return yRange; + } + + /** + * @param yRange + * the yRange to set + */ + public void setyRange(int yRange) { + this.yRange = yRange; + } + + /** + * @return the zRange + */ + public int getzRange() { + return zRange; + } + + /** + * @param zRange + * the zRange to set + */ + public void setzRange(int zRange) { + this.zRange = zRange; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/QuickieItems.java b/src/main/java/de/jottyfan/quickiemod/items/QuickieItems.java index 2106a80..cb9ae0e 100644 --- a/src/main/java/de/jottyfan/quickiemod/items/QuickieItems.java +++ b/src/main/java/de/jottyfan/quickiemod/items/QuickieItems.java @@ -9,7 +9,22 @@ import net.minecraft.item.Item; */ public enum QuickieItems { // @formatter:off - SPEEDPOWDERSHEARS(new ItemSpeedpowdershears(), "speedpowdershears"), + SPEEDPOWDER(new ItemSpeedpowder(), "speedpowder"), + QUICKIEPOWDER(new ItemQuickiepowder(), "quickiepowder"), + OXIDIZEDCOPPERPOWDER(new ItemOxidizedcopperpowder(), "oxidizedcopperpowder"), + SPEEDINGOT(new ItemSpeedingot(), "speedingot"), + QUICKIEINGOT(new ItemQuickieingot(), "quickieingot"), + SPEEDPOWDERAXE(new ToolSpeedpowderAxe(), "speedpowderaxe"), + SPEEDPOWDERPICKAXE(new ToolSpeedpowderPickaxe(), "speedpowderpickaxe"), + SPEEDPOWDERSHOVEL(new ToolSpeedpowderShovel(), "speedpowdershovel"), + SPEEDPOWDERHOE(new ToolSpeedpowderHoe(), "speedpowderhoe"), + SPEEDPOWDERWATERHOE(new ToolSpeedpowderWaterHoe(), "speedpowderwaterhoe"), + SPEEDPOWDERSHEARS(new ToolSpeedpowderShears(), "speedpowdershears"), + QUICKIEPOWDERAXE(new ToolQuickiepowderAxe(), "quickiepowderaxe"), + QUICKIEPOWDERPICKAXE(new ToolQuickiepowderPickaxe(), "quickiepowderpickaxe"), + QUICKIEPOWDERSHOVEL(new ToolQuickiepowderShovel(), "quickiepowdershovel"), + QUICKIEPOWDERHOE(new ToolQuickiepowderHoe(), "quickiepowderhoe"), + QUICKIEPOWDERWATERHOE(new ToolQuickiepowderWaterHoe(), "quickiepowderwaterhoe"), ROTTEN_FLESH_STRIPES(new ItemRottenFleshStripes(), "rotten_flesh_stripes"), CARROTSTACK(new ItemCarrotstack(), "carrotstack"), COTTON(new ItemCotton(), "cotton"), @@ -20,12 +35,7 @@ public enum QuickieItems { CANOLABOTTLESTACK(new ItemCanolabottlestack(), "canolabottlestack"), STUB(new ItemStub(), "stub"), SALPETER(new ItemSalpeter(), "salpeter"), - SULPHOR(new ItemSulphor(), "sulphor"), - SPEEDPOWDER(new ItemSpeedpowder(), "speedpowder"), - QUICKIEPOWDER(new ItemQuickiepowder(), "quickiepowder"), - OXIDIZEDCOPPERPOWDER(new ItemOxidizedcopperpowder(), "oxidizedcopperpowder"), - SPEEDINGOT(new ItemSpeedingot(), "speedingot"), - QUICKIEINGOT(new ItemQuickieingot(), "quickieingot"); + SULPHOR(new ItemSulphor(), "sulphor"); // @formatter:on private final Item item; diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderAxe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderAxe.java new file mode 100644 index 0000000..74829f4 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderAxe.java @@ -0,0 +1,26 @@ +package de.jottyfan.quickiemod.items; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.item.AxeItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/** + * + * @author jotty + * + */ +public class ToolQuickiepowderAxe extends ToolRangeableAxe { + + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 2400, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolQuickiepowderAxe() { + super(MATERIAL, new Item.Settings().attributeModifiers(AxeItem.createAttributeModifiers(MATERIAL, 7F, -3.1F))); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get the range from the stack + return new HarvestRange(64, 128, 64); // trees bigger than that are too heavy for one small axe... + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderHoe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderHoe.java new file mode 100644 index 0000000..a036c49 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderHoe.java @@ -0,0 +1,20 @@ +package de.jottyfan.quickiemod.items; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.item.HoeItem; +import net.minecraft.item.Item; + +/** + * + * @author jotty + * + */ +public class ToolQuickiepowderHoe extends ToolRangeableHoe { + + public static final Integer DEFAULT_PLOW_RANGE = 4; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 2400, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolQuickiepowderHoe() { + super(MATERIAL, new Item.Settings().attributeModifiers(HoeItem.createAttributeModifiers(MATERIAL, 7F, -3.1F)), new HarvestRange(DEFAULT_PLOW_RANGE)); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderPickaxe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderPickaxe.java new file mode 100644 index 0000000..dc1dbcc --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderPickaxe.java @@ -0,0 +1,54 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.PickaxeItem; + +/** + * + * @author jotty + * + */ +public class ToolQuickiepowderPickaxe extends PickaxeItem implements ToolRangeable { + + public static final int[] DEFAULT_HARVEST_RANGE = new int[] { 6, 6, 6 }; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 2400, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolQuickiepowderPickaxe() { + super(MATERIAL, new Item.Settings().attributeModifiers(PickaxeItem.createAttributeModifiers(MATERIAL, 7F, -3.1F))); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + return new HarvestRange(DEFAULT_HARVEST_RANGE); + } + + @Override + public boolean canBreakNeighbors(BlockState blockIn) { + return new ItemStack(this).isSuitableFor(blockIn); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } + +// @Override +// public ActionResult onItemRightClick(World worldIn, PlayerEntity playerIn, Hand handIn) { +// CommonToolCode.onItemRightClick(worldIn, playerIn, handIn); +// return super.onItemRightClick(worldIn, playerIn, handIn); +// } +// +// @Override +// public void addInformation(ItemStack stack, World worldIn, List tooltip, ITooltipFlag flagIn) { +// CommonToolCode.addInformation(stack, worldIn, tooltip, flagIn); +// super.addInformation(stack, worldIn, tooltip, flagIn); +// } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderShovel.java b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderShovel.java new file mode 100644 index 0000000..3ee6f49 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderShovel.java @@ -0,0 +1,97 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.item.ShovelItem; +import net.minecraft.util.ActionResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class ToolQuickiepowderShovel extends ShovelItem implements ToolRangeable { + public static final Integer DEFAULT_HARVEST_RANGE = 6; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 2400, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + public HarvestRange range; + + public ToolQuickiepowderShovel() { + super(MATERIAL, new Item.Settings().attributeModifiers(ShovelItem.createAttributeModifiers(MATERIAL, 7F, -3.1F))); + this.range = new HarvestRange(DEFAULT_HARVEST_RANGE); + } + + private void createPathOnGrass(World world, BlockPos pos, Direction side) { + BlockState blockState = world.getBlockState(pos); + if (blockState.isAir()) { + // try to find one underneath + pos = pos.down(); + blockState = world.getBlockState(pos); + } else if (!world.getBlockState(pos.up()).isAir()) { + pos = pos.up(); + blockState = world.getBlockState(pos); + } + if (side != Direction.DOWN) { + BlockState blockState2 = (BlockState) PATH_STATES.get(blockState.getBlock()); + if (blockState2 != null && world.getBlockState(pos.up()).isAir()) { + if (!world.isClient) { + world.setBlockState(pos, blockState2, 11); + } + } + } + } + + @Override + public ActionResult useOnBlock(ItemUsageContext context) { + World world = context.getWorld(); + BlockPos pos = context.getBlockPos(); + BlockPos[] positions = new BlockPos[] { pos.north().north().west().west(), pos.north().north().west(), + pos.north().north(), pos.north().north().east(), pos.north().north().east().east(), pos.north().west().west(), + pos.north().west(), pos.north(), pos.north().east(), pos.north().east().east(), pos.west().west(), pos.west(), + pos, pos.east(), pos.east().east(), pos.south().west().west(), pos.south().west(), pos.south(), + pos.south().east(), pos.south().east().east(), pos.south().south().west().west(), pos.south().south().west(), + pos.south().south(), pos.south().south().east(), pos.south().south().east().east() }; + for (BlockPos p : positions) { + createPathOnGrass(world, p, context.getSide()); + } + return super.useOnBlock(context); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get range from stack + return range; + } + + @Override + public boolean canBreakNeighbors(BlockState blockState) { + return new ItemStack(this).isSuitableFor(blockState); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } + +// @Override +// public ActionResult onItemRightClick(World worldIn, PlayerEntity playerIn, Hand handIn) { +// CommonToolCode.onItemRightClick(worldIn, playerIn, handIn); +// return super.onItemRightClick(worldIn, playerIn, handIn); +// } +// +// @Override +// public void addInformation(ItemStack stack, World worldIn, List tooltip, ITooltipFlag flagIn) { +// CommonToolCode.addInformation(stack, worldIn, tooltip, flagIn); +// super.addInformation(stack, worldIn, tooltip, flagIn); +// } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderWaterHoe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderWaterHoe.java new file mode 100644 index 0000000..4d9189e --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolQuickiepowderWaterHoe.java @@ -0,0 +1,38 @@ +package de.jottyfan.quickiemod.items; + +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.entity.ItemEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.util.ActionResult; +import net.minecraft.util.Hand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class ToolQuickiepowderWaterHoe extends ToolQuickiepowderHoe { + @Override + public ActionResult useOnBlock(ItemUsageContext context) { + ActionResult res = super.useOnBlock(context); + if (!ActionResult.PASS.equals(res)) { + BlockPos pos = context.getBlockPos(); + World world = context.getWorld(); + BlockState oldBlockState = world.getBlockState(pos); + world.setBlockState(pos, Blocks.WATER.getDefaultState()); + Hand hand = context.getHand(); + PlayerEntity player = context.getPlayer(); + ItemStack oldTool = player.getStackInHand(hand); + ItemStack newTool = new ItemStack(QuickieItems.QUICKIEPOWDERHOE.getItem()); + newTool.setDamage(oldTool.getDamage()); + world.spawnEntity(new ItemEntity(world, pos.getX(), pos.getY(), pos.getZ(), new ItemStack(oldBlockState.getBlock()))); + player.setStackInHand(hand, newTool); + } + return res; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolRangeable.java b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeable.java new file mode 100644 index 0000000..a793612 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeable.java @@ -0,0 +1,38 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.ItemStack; + +/** + * + * @author jotty + * + */ +public interface ToolRangeable { + + /** + * @param stack the item stack that keeps the range + * @return range of blocks to be harvested + */ + public HarvestRange getRange(ItemStack stack); + + /** + * check if this block state is one that affects the neighbor blocks to break + * also if they are from the same type + * + * @param blockState the block state of the current block + * @return true or false + */ + public boolean canBreakNeighbors(BlockState blockState); + + /** + * get list of blocks that belong together (could be useful for stripped logs) + * + * @param block of the set + * @return the list of blocks or null if not found + */ + public List getBlockList(Block block); +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableAxe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableAxe.java new file mode 100644 index 0000000..253011c --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableAxe.java @@ -0,0 +1,63 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.LeavesBlock; +import net.minecraft.item.AxeItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ToolMaterial; +import net.minecraft.registry.tag.BlockTags; + +/** + * + * @author jotty + * + */ +public abstract class ToolRangeableAxe extends AxeItem implements ToolRangeable { + + protected ToolRangeableAxe(ToolMaterial material, Item.Settings settings) { + super(material, settings); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get the range from the stack + return new HarvestRange(16, 32, 16); + } + + /** + * check if the block is a leaves block + * + * @param blockIn the block + * @return true or false + */ + private boolean isLeavesBlock(BlockState blockIn) { + boolean vanillaLeaves = blockIn.getBlock() instanceof LeavesBlock; + boolean terrestriaLeaves = false; + try { + Class extendedLeavesBlock = Class.forName("com.terraformersmc.terraform.leaves.block.ExtendedLeavesBlock"); + terrestriaLeaves = extendedLeavesBlock.isInstance(blockIn.getBlock()); + } catch (ClassNotFoundException e) { + // no terrestria mod available, so ignore this + // using this approach instead of the instanceof functionality, we don't need to refer to terrestria + // and omit a crash on installations that do not have or want terrestria available + } + boolean blockTagLeaves = blockIn.isIn(BlockTags.LEAVES); + return vanillaLeaves || terrestriaLeaves || blockTagLeaves; + } + + @Override + public boolean canBreakNeighbors(BlockState blockIn) { + return new ItemStack(this).isSuitableFor(blockIn) || isLeavesBlock(blockIn) || blockIn.isIn(BlockTags.LOGS); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableHoe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableHoe.java new file mode 100644 index 0000000..51d3b3f --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolRangeableHoe.java @@ -0,0 +1,97 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.block.CropBlock; +import net.minecraft.item.HoeItem; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.item.ToolMaterial; +import net.minecraft.util.ActionResult; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.util.math.Vec3i; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public abstract class ToolRangeableHoe extends HoeItem implements ToolRangeable { + + public HarvestRange range; + + public ToolRangeableHoe(ToolMaterial material, Settings settings, HarvestRange range) { + super(material, settings); + this.range = range; + } + + @Override + public ActionResult useOnBlock(ItemUsageContext context) { + ActionResult res = super.useOnBlock(context); + boolean isCrop = context.getWorld().getBlockState(context.getBlockPos()).getBlock() instanceof CropBlock; + if (!ActionResult.PASS.equals(res) || isCrop) { + for (int x = -this.range.getxRange(); x <= this.range.getxRange(); x++) { + for (int y = -this.range.getyRange(); y <= this.range.getyRange(); y++) { + for (int z = -this.range.getzRange(); z <= this.range.getzRange(); z++) { + if (!isCrop) { + removePossibleGrass(context.getWorld(), new BlockPos(x, y, z)); + BlockHitResult bhr = new BlockHitResult(context.getHitPos(), Direction.UP, + context.getBlockPos().add(new Vec3i(x, y, z)), false); + ItemUsageContext ctx = new ItemUsageContext(context.getPlayer(), context.getHand(), bhr); + super.useOnBlock(ctx); + } else { + harvestIfPossible(context.getBlockPos().add(x, y, z), context.getWorld()); + } + } + } + } + } + return res; + } + + private void removePossibleGrass(World world, BlockPos pos) { + Block block = world.getBlockState(pos).getBlock(); + Boolean grassFound = Blocks.FERN.equals(block) || Blocks.LARGE_FERN.equals(block) + || Blocks.SHORT_GRASS.equals(block) || Blocks.TALL_GRASS.equals(block); + if (grassFound) { + world.breakBlock(pos, true); + } + } + + private void harvestIfPossible(BlockPos pos, World world) { + BlockState blockState = world.getBlockState(pos); + Block block = blockState.getBlock(); + if (block instanceof CropBlock) { + CropBlock cBlock = (CropBlock) block; + if (cBlock.isMature(blockState)) { + Block.dropStacks(blockState, world, pos); + world.setBlockState(pos, cBlock.withAge(0)); + } + } + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get range from stack + return range; + } + + @Override + public boolean canBreakNeighbors(BlockState blockState) { + return new ItemStack(this).isSuitableFor(blockState) || Blocks.TALL_GRASS.equals(blockState.getBlock()) + || Blocks.FERN.equals(blockState.getBlock()) || Blocks.LARGE_FERN.equals(blockState.getBlock()); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderAxe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderAxe.java new file mode 100644 index 0000000..73e926a --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderAxe.java @@ -0,0 +1,26 @@ +package de.jottyfan.quickiemod.items; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.PickaxeItem; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderAxe extends ToolRangeableAxe { + + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 800, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolSpeedpowderAxe() { + super(MATERIAL, new Item.Settings().attributeModifiers(PickaxeItem.createAttributeModifiers(MATERIAL, 7f, -3.1f))); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get the range from the stack + return new HarvestRange(32, 64, 32); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderHoe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderHoe.java new file mode 100644 index 0000000..14edd2a --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderHoe.java @@ -0,0 +1,20 @@ +package de.jottyfan.quickiemod.items; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.item.HoeItem; +import net.minecraft.item.Item; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderHoe extends ToolRangeableHoe { + + public static final Integer DEFAULT_PLOW_RANGE = 2; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 800, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolSpeedpowderHoe() { + super(MATERIAL, new Item.Settings().attributeModifiers(HoeItem.createAttributeModifiers(MATERIAL, 7F, -3.1F)), new HarvestRange(DEFAULT_PLOW_RANGE)); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderPickaxe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderPickaxe.java new file mode 100644 index 0000000..2d5d3de --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderPickaxe.java @@ -0,0 +1,55 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.AxeItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.PickaxeItem; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderPickaxe extends PickaxeItem implements ToolRangeable { + + public static final int[] DEFAULT_HARVEST_RANGE = new int[] { 3, 3, 3 }; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 800, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + + public ToolSpeedpowderPickaxe() { + super(MATERIAL, new Item.Settings().attributeModifiers(AxeItem.createAttributeModifiers(MATERIAL, 7F, -3.1F))); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + return new HarvestRange(DEFAULT_HARVEST_RANGE); + } + + @Override + public boolean canBreakNeighbors(BlockState blockIn) { + return new ItemStack(this).isSuitableFor(blockIn); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } + +// @Override +// public ActionResult onItemRightClick(World worldIn, PlayerEntity playerIn, Hand handIn) { +// CommonToolCode.onItemRightClick(worldIn, playerIn, handIn); +// return super.onItemRightClick(worldIn, playerIn, handIn); +// } +// +// @Override +// public void addInformation(ItemStack stack, World worldIn, List tooltip, ITooltipFlag flagIn) { +// CommonToolCode.addInformation(stack, worldIn, tooltip, flagIn); +// super.addInformation(stack, worldIn, tooltip, flagIn); +// } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShears.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShears.java new file mode 100644 index 0000000..ae75d84 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShears.java @@ -0,0 +1,96 @@ +package de.jottyfan.quickiemod.items; + +import java.util.Random; + +import net.minecraft.component.DataComponentTypes; +import net.minecraft.entity.ItemEntity; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.passive.ChickenEntity; +import net.minecraft.entity.passive.CowEntity; +import net.minecraft.entity.passive.HorseEntity; +import net.minecraft.entity.passive.SheepEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.item.ShearsItem; +import net.minecraft.util.ActionResult; +import net.minecraft.util.DyeColor; +import net.minecraft.util.Hand; +import net.minecraft.util.math.Vec3d; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderShears extends ShearsItem { + + public ToolSpeedpowderShears() { + super(new Item.Settings().component(DataComponentTypes.TOOL, ShearsItem.createToolComponent())); + } + + @Override + public ActionResult useOnEntity(ItemStack stack, PlayerEntity user, LivingEntity entity, Hand hand) { + Vec3d pos = entity.getPos(); + Integer amount = 3 + new Random().nextInt(4); + if (entity instanceof SheepEntity) { + SheepEntity sheep = (SheepEntity) entity; + if (sheep.isShearable()) { + sheep.setSheared(true); + sheep.playAmbientSound(); + DyeColor color = sheep.getColor(); + Item item = Items.WHITE_WOOL; + if (color.equals(DyeColor.BLACK)) { + item = Items.BLACK_WOOL; + } else if (color.equals(DyeColor.GRAY)) { + item = Items.GRAY_WOOL; + } else if (color.equals(DyeColor.LIGHT_GRAY)) { + item = Items.LIGHT_GRAY_WOOL; + } else if (color.equals(DyeColor.BROWN)) { + item = Items.BROWN_WOOL; + } else if (color.equals(DyeColor.BLUE)) { + item = Items.BLUE_WOOL; + } else if (color.equals(DyeColor.LIGHT_BLUE)) { + item = Items.LIGHT_BLUE_WOOL; + } else if (color.equals(DyeColor.GREEN)) { + item = Items.GREEN_WOOL; + } else if (color.equals(DyeColor.LIME)) { + item = Items.LIME_WOOL; + } else if (color.equals(DyeColor.CYAN)) { + item = Items.CYAN_WOOL; + } else if (color.equals(DyeColor.MAGENTA)) { + item = Items.MAGENTA_WOOL; + } else if (color.equals(DyeColor.ORANGE)) { + item = Items.ORANGE_WOOL; + } else if (color.equals(DyeColor.PINK)) { + item = Items.PINK_WOOL; + } else if (color.equals(DyeColor.PURPLE)) { + item = Items.PURPLE_WOOL; + } else if (color.equals(DyeColor.RED)) { + item = Items.RED_WOOL; + } else if (color.equals(DyeColor.YELLOW)) { + item = Items.YELLOW_WOOL; + } + user.getWorld().spawnEntity(new ItemEntity(user.getWorld(), pos.getX(), pos.getY(), pos.getZ(), new ItemStack(item, amount))); + return ActionResult.SUCCESS; + } + } else if (entity instanceof HorseEntity) { + HorseEntity horse = (HorseEntity) entity; + horse.playAmbientSound(); + user.getWorld().spawnEntity(new ItemEntity(user.getWorld(), pos.getX(), pos.getY(), pos.getZ(), new ItemStack(Items.LEATHER, amount))); + return ActionResult.SUCCESS; + } else if (entity instanceof CowEntity) { + CowEntity cow = (CowEntity) entity; + cow.playAmbientSound(); + user.getWorld().spawnEntity(new ItemEntity(user.getWorld(), pos.getX(), pos.getY(), pos.getZ(), new ItemStack(Items.LEATHER, amount))); + return ActionResult.SUCCESS; + } else if (entity instanceof ChickenEntity) { + ChickenEntity cow = (ChickenEntity) entity; + cow.playAmbientSound(); + user.getWorld().spawnEntity(new ItemEntity(user.getWorld(), pos.getX(), pos.getY(), pos.getZ(), new ItemStack(Items.FEATHER, amount))); + return ActionResult.SUCCESS; + } + return ActionResult.PASS; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShovel.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShovel.java new file mode 100644 index 0000000..b26e527 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderShovel.java @@ -0,0 +1,96 @@ +package de.jottyfan.quickiemod.items; + +import java.util.List; + +import com.google.common.collect.Lists; + +import de.jottyfan.quickiemod.items.mat.QuickieToolMaterial; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.item.ShovelItem; +import net.minecraft.util.ActionResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderShovel extends ShovelItem implements ToolRangeable { + public static final Integer DEFAULT_HARVEST_RANGE = 3; + private final static QuickieToolMaterial MATERIAL = QuickieToolMaterial.of(7f, 800, 15, 1f, QuickieItems.SPEEDINGOT.getItem()); + public HarvestRange range; + + public ToolSpeedpowderShovel() { + super(MATERIAL, new Item.Settings().attributeModifiers(ShovelItem.createAttributeModifiers(MATERIAL, 7F, -3.1F))); + this.range = new HarvestRange(DEFAULT_HARVEST_RANGE); + } + + private void createPathOnGrass(World world, BlockPos pos, Direction side) { + BlockState blockState = world.getBlockState(pos); + if (blockState.isAir()) { + // try to find one underneath + pos = pos.down(); + blockState = world.getBlockState(pos); + } else if (!world.getBlockState(pos.up()).isAir()) { + pos = pos.up(); + blockState = world.getBlockState(pos); + } + if (side != Direction.DOWN) { + BlockState blockState2 = (BlockState) PATH_STATES.get(blockState.getBlock()); + if (blockState2 != null && world.getBlockState(pos.up()).isAir()) { + if (!world.isClient) { + world.setBlockState(pos, blockState2, 11); + } + } + } + } + + @Override + public ActionResult useOnBlock(ItemUsageContext context) { + World world = context.getWorld(); + BlockPos pos = context.getBlockPos(); + createPathOnGrass(world, pos.north(), context.getSide()); + createPathOnGrass(world, pos.north().east(), context.getSide()); + createPathOnGrass(world, pos.north().west(), context.getSide()); + createPathOnGrass(world, pos.east(), context.getSide()); + createPathOnGrass(world, pos.west(), context.getSide()); + createPathOnGrass(world, pos.south(), context.getSide()); + createPathOnGrass(world, pos.south().east(), context.getSide()); + createPathOnGrass(world, pos.south().west(), context.getSide()); + return super.useOnBlock(context); + } + + @Override + public HarvestRange getRange(ItemStack stack) { + // TODO: get range from stack + return range; + } + + @Override + public boolean canBreakNeighbors(BlockState blockState) { + return new ItemStack(this).isSuitableFor(blockState); + } + + @Override + public List getBlockList(Block block) { + return Lists.newArrayList(block); + } + +// @Override +// public ActionResult onItemRightClick(World worldIn, PlayerEntity playerIn, Hand handIn) { +// CommonToolCode.onItemRightClick(worldIn, playerIn, handIn); +// return super.onItemRightClick(worldIn, playerIn, handIn); +// } +// +// @Override +// public void addInformation(ItemStack stack, World worldIn, List tooltip, ITooltipFlag flagIn) { +// CommonToolCode.addInformation(stack, worldIn, tooltip, flagIn); +// super.addInformation(stack, worldIn, tooltip, flagIn); +// } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderWaterHoe.java b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderWaterHoe.java new file mode 100644 index 0000000..c7381fb --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/ToolSpeedpowderWaterHoe.java @@ -0,0 +1,38 @@ +package de.jottyfan.quickiemod.items; + +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.entity.ItemEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.util.ActionResult; +import net.minecraft.util.Hand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +public class ToolSpeedpowderWaterHoe extends ToolSpeedpowderHoe { + @Override + public ActionResult useOnBlock(ItemUsageContext context) { + ActionResult res = super.useOnBlock(context); + if (!ActionResult.PASS.equals(res)) { + BlockPos pos = context.getBlockPos(); + World world = context.getWorld(); + BlockState oldBlockState = world.getBlockState(pos); + world.setBlockState(pos, Blocks.WATER.getDefaultState()); + Hand hand = context.getHand(); + PlayerEntity player = context.getPlayer(); + ItemStack oldTool = player.getStackInHand(hand); + ItemStack newTool = new ItemStack(QuickieItems.SPEEDPOWDERHOE.getItem()); + newTool.setDamage(oldTool.getDamage()); + world.spawnEntity(new ItemEntity(world, pos.getX(), pos.getY(), pos.getZ(), new ItemStack(oldBlockState.getBlock()))); + player.setStackInHand(hand, newTool); + } + return res; + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/items/mat/QuickieToolMaterial.java b/src/main/java/de/jottyfan/quickiemod/items/mat/QuickieToolMaterial.java new file mode 100644 index 0000000..dc7028d --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/items/mat/QuickieToolMaterial.java @@ -0,0 +1,64 @@ +package de.jottyfan.quickiemod.items.mat; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ToolMaterial; +import net.minecraft.recipe.Ingredient; +import net.minecraft.registry.tag.BlockTags; +import net.minecraft.registry.tag.TagKey; + +/** + * + * @author jotty + * + */ +public class QuickieToolMaterial implements ToolMaterial { + + private final float attackDamage; + private final int durability; + private final int enchantability; + private final float miningSpeedMuliplier; + private final Item item; + + private QuickieToolMaterial(float attackDamage, int durability, int enchantability, float miningSpeedMultiplier, Item item) { + this.attackDamage = attackDamage; + this.durability = durability; + this.enchantability = enchantability; + this.miningSpeedMuliplier = miningSpeedMultiplier; + this.item = item; + } + + public static final QuickieToolMaterial of(float attackDamage, int durability, int enchantability, float miningSpeedMultiplier, Item item) { + return new QuickieToolMaterial(attackDamage, durability, enchantability, miningSpeedMultiplier, item); + } + + @Override + public float getAttackDamage() { + return attackDamage; + } + + @Override + public int getDurability() { + return durability; + } + + @Override + public int getEnchantability() { + return enchantability; + } + + @Override + public TagKey getInverseTag() { + return BlockTags.INCORRECT_FOR_IRON_TOOL; + } + + @Override + public float getMiningSpeedMultiplier() { + return miningSpeedMuliplier; + } + + @Override + public Ingredient getRepairIngredient() { + return Ingredient.ofItems(item); + } +} diff --git a/src/main/java/de/jottyfan/quickiemod/mixin/BlockBreakMixin.java b/src/main/java/de/jottyfan/quickiemod/mixin/BlockBreakMixin.java new file mode 100644 index 0000000..537dca3 --- /dev/null +++ b/src/main/java/de/jottyfan/quickiemod/mixin/BlockBreakMixin.java @@ -0,0 +1,33 @@ +package de.jottyfan.quickiemod.mixin; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import de.jottyfan.quickiemod.event.BreakBlockCallback; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.util.ActionResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * + * @author jotty + * + */ +@Mixin(Block.class) +public class BlockBreakMixin { + + @Inject(at = @At("HEAD"), method = "onBreak(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/entity/player/PlayerEntity;)Lnet/minecraft/block/BlockState;") + private void onBreak(final World world, final BlockPos blockPos, final BlockState blockState, + final PlayerEntity playerEntity, final CallbackInfoReturnable info) { + ActionResult result = BreakBlockCallback.EVENT.invoker().injectBlockBreakCallback(world, blockPos, blockState, + playerEntity); + if (result == ActionResult.FAIL) { + info.cancel(); + } + } +} diff --git a/src/main/resources/assets/quickiemod/models/item/quickiepowderaxe.json b/src/main/resources/assets/quickiemod/models/item/quickiepowderaxe.json new file mode 100644 index 0000000..0cea2f2 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/quickiepowderaxe.json @@ -0,0 +1,6 @@ +{ + "parent": "minecraft:item/handheld", + "textures": { + "layer0": "quickiemod:item/quickiepowderaxe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/quickiepowderhoe.json b/src/main/resources/assets/quickiemod/models/item/quickiepowderhoe.json new file mode 100644 index 0000000..ead1c19 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/quickiepowderhoe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/quickiepowderhoe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/quickiepowderpickaxe.json b/src/main/resources/assets/quickiemod/models/item/quickiepowderpickaxe.json new file mode 100644 index 0000000..1f56799 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/quickiepowderpickaxe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/quickiepowderpickaxe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/quickiepowdershovel.json b/src/main/resources/assets/quickiemod/models/item/quickiepowdershovel.json new file mode 100644 index 0000000..a4d63b1 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/quickiepowdershovel.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/quickiepowdershovel" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/quickiepowderwaterhoe.json b/src/main/resources/assets/quickiemod/models/item/quickiepowderwaterhoe.json new file mode 100644 index 0000000..e64a3ba --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/quickiepowderwaterhoe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/quickiepowderwaterhoe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/speedpowderaxe.json b/src/main/resources/assets/quickiemod/models/item/speedpowderaxe.json new file mode 100644 index 0000000..60144a3 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/speedpowderaxe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/speedpowderaxe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/speedpowderhoe.json b/src/main/resources/assets/quickiemod/models/item/speedpowderhoe.json new file mode 100644 index 0000000..9a41b20 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/speedpowderhoe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/speedpowderhoe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/speedpowderpickaxe.json b/src/main/resources/assets/quickiemod/models/item/speedpowderpickaxe.json new file mode 100644 index 0000000..3e7d09b --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/speedpowderpickaxe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/speedpowderpickaxe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/speedpowdershovel.json b/src/main/resources/assets/quickiemod/models/item/speedpowdershovel.json new file mode 100644 index 0000000..a99ff48 --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/speedpowdershovel.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/speedpowdershovel" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/models/item/speedpowderwaterhoe.json b/src/main/resources/assets/quickiemod/models/item/speedpowderwaterhoe.json new file mode 100644 index 0000000..37507fc --- /dev/null +++ b/src/main/resources/assets/quickiemod/models/item/speedpowderwaterhoe.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "quickiemod:item/speedpowderwaterhoe" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/quickiemod/textures/item/quickiepowderaxe.png b/src/main/resources/assets/quickiemod/textures/item/quickiepowderaxe.png new file mode 100644 index 0000000000000000000000000000000000000000..c658e6d17b399a1d25a5459428164c38b668d545 GIT binary patch literal 4411 zcmeHKeNYtV8DC0-gb$0s#G_KPo{jjmce{JvD~AGiz!^@y&PFn*?CtKs2JUvbTeyP; ztqK@PHK>ga76mibsUNW!87B}dXvNVH1RW=d6Q&_Rr#96T3#QRfyuN#Pd`&ZxVW#2q-pq}ukzqdzgCHoiSvV(K7VPfHX$h1^49*ozbqe5Y}{rkYgQlYTp+=v z15Yk(8@RI|ch|}HTmP0Gaypx8UeCTCX*+o3`0bcA-|#Qo+3?|F#U~HP3y!fRgSM=X zW4^juZGY)ZOUEP)JO0`TSpRkGh?nPrY{Tz}JqtEK_D<=gT8pM%s#U>|b znv#iR36Z$UCmrrosna_Q@eYfF?N?FuI&$RQy(NPSXK4LiA|x0jyy{|RP&2# z*Rps-`=ohuDPQvGCs#H_J-1_h-j;@iTTXV49ZY&h@=D$p*UN`v|JnA_sDCi0a(|Ak zziU^#_x3yW56|5Drgm#Y_P(ULdZycy{bKur2TOw5`;Fy?y?ORu*M(fR^l_QI4oZsEVKRcaLcUgKEPORFsYQu`FDZec{wlI7p@$T4@ zJzF{qvg*87QRkYbpG01G5bE9C-+XZ-=g`*d74wC5ZO?Vd?Tg{cH}{WLKGg1uhMz>_ zeTD4!{rv9j2e%fn2bMMMSlrU$U~ewrTZ1F?F&9?0W!G)EaewExitkRXLHY2<=gM70 z$A=yVrQJPuP;>dpQgmz6!_r2#`=j2k``6xjIu6-_ohRDvyq635u7U;qwb`6bP@G*x z(wvo%dF(uBJP3+k=iy1Jh!J2bQ@}d((&4raDa_J(>FX*pYUY!fLN=|!$>daQv``gA zl#Z6JO9+ei5P-nW2qf&W7du>pM=$m965v@h%cZanA{6PRo6VVUGUsGqrA#S95u=AK z!=(vfaJ-YY5!r^600kK7rGs9jlR0yeK}@NDwe!BDfOs>U(bOc4FLf6C zFf=7+iWxf~b%FS>8F+!UO^G!lHgU$6&h$WlyGi~T=!x8YV1P242?Ix!icU=iy;O{s zpgD@A3Ev~BA}J-Nq7W;k&>%{iR)gp;96VvTg3?+UEspA@QJEYrfpk!eNCn7cEZ|X~ zv_hjoafGpvG@?{1Rftt z2&AYQra@7SLZ`towHjBclvAKzGENuhIFS@XWeUG5nj%sFB?&r*wUY&moOcxXmWXvB zKsG>GQfySf?6ZSph-4>23Y^ozam9M67%VJOPEMP_exgZ%G>`%VyrH;)z%T+=STLMW zVuVV&8pQ~78lIzBTlo*6#oYtP`)i)Yx`6+3pUJRHGzIEtRjIT# z?M!wTXA|6{lSwQ9Is&agfBLk7SNKb~awgne$cXg;iXj+=1Qf#w6bmRO4`eJCPmPI` z zt~t48rNFGfbKUiSlPhfMgNkv0*C03eTzZiceg{6aLaeW)8Xz_FD~P>*tjk@~IGlj}$K$OZxIfk#VZBI3g!Xh8H|^;SPx&~+8zYfO?%lg5F`P|~ z*?!5}`Do~BTutxjzZH2c6?+flOB&kV+L_fbx^nl<$Kf@7^CF{yzo=ZE5E6gO;B}um z>;0^5=-IogiI{(}hmU+oYxx1>>b}%%C1-L{Cjfwkv literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/quickiepowderhoe.png b/src/main/resources/assets/quickiemod/textures/item/quickiepowderhoe.png new file mode 100644 index 0000000000000000000000000000000000000000..b74b377bb594e119d795f046ac2bedba6cac8fe0 GIT binary patch literal 4382 zcmeHLYfuzd7H&`=GN6cB;)>V~oAQA@(>>GkY8i20cubPvF<=Bs4E?wRE%eOL(=Y=S zMU5{|6UB{|XhbVn)LoZNw36tO6P;$^d z)FZl`d<8(I8V^8$pLZgN|7#)lT66~*^`x}n^&6}FyV9BpZimln&&2a~h_T!I&P=`Y z?!fuxyX#^;D0#8_y^pgt&PsAj=Wd^f(0+CC$mh?s)EdJqw#xDx?}KM~rA>#=Dp#vA ze(d`brRe;7%Jp4O76>V^lMl_EWpI2S+Ggov^Ol;5GYfr9dmm5PP0st~_@B)mZs`*g z4NFcZC2d;C4s873ZA;SR@I*`Ex2@~S%9ArXQ;+*2!jJ_B60(I)OUt#T zr46M6lQ_J7uQ{tDcjnfd{PZgguZ5+@Z!TEac47znyVU7RwyZw3GGgC>XO?~2e%aZX z=fRBqX9}x4m4Ex|#g#FW>sG8OK0LGdosSRNIO`)u{O?xywkW^WT8b!)ynnX%`BazAR>vU$l1i#jrXRsGgX#bWA>$Nk%j z+pVgtYo5o&rAI@fPxnR)ymtM}`}gwqt#vG#DxEie))n{p`wDX1>-X2+G47s$_D8Mx z9;^HH)SeBEYs>k)iAU?^o;~a0yAwR;CPkU&oL=1K*z>}rTbmwgAGIvSJ&FgXYP{t~ zzI_mq^~I@1!-b0r@U=(pR5km2AO5B9`m)PEK1H09#A9t&-YkM;SIfilDzv{uv2H;{ zb8ZHx{DKG89fBmM_&qdR4kVNTrM%0m{GqK~iSnFTxk_ip?VdDH#%I-vAip-dfUPZO zO`I}id1SJmf&>DPXw)xMxV)6#tPJo{@Lo2nm1qDWm7A4?_FOd0EdrEOkt!TZ_w&^n z&9Q!yTD&aUf6rbR++lT30-a!?h9%?`BQ4=a$EePt-GrUrI zH6$4f=qG1*3*atQJAl_+C9)vB8n~py(G;0Bd+soUoKh(-cmhd5@y0mg*kPQfN~{QA zI93fRfB;FoFg{`oUgDi2VvUJS9tor~IuPh?n12jSn8Cr#7ouDaT83 zZkFe$z%Ai4vA9!5VmgK;Fj8k^Fh*|xnBHVGaYjJ1G|h~nvbnqx?P7sU1<6%BqzpfdOre5~LDdkIAYyMm(GUwlCNX)x+&@P&B#m{EWxoV*HFAAoYZkap^lD*MwZ-Qea%*iRzk= zYg`J93p`O>|2MfJM?R>43%&;V;OA1#6|56}YK1c|W?B&u89+Y0RJSk;TBdliio6J- zm?57bNYmjsXpE3-_VkEbirI=J^{KkMuR_x&Hmjw;_$ga*GzP!9kK{`Fr?Jgl$M%Oc zJG%ys&)Km4=_hylzFQU^{@sOvt5FwwLro_XA7x{l|6$*<4q<5DkuS)RN8r0W?A_i2wiq literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/quickiepowderpickaxe.png b/src/main/resources/assets/quickiemod/textures/item/quickiepowderpickaxe.png new file mode 100644 index 0000000000000000000000000000000000000000..f12ad7e73d2f14c61017d912b76a5c04dde24bde GIT binary patch literal 4404 zcmeHKc~BHr8gGLE!(lLx5;q>rU0^4Pr^7G;GsvKW2onw$kDl%x=w&Wu8fL&X zL_8wnfnX9NAs(r$wI-TF%8D+DKv);ofJeEy8nV$f>sqU1&1%*dOqP8;+?7;qQMLJx zsp{!|-}igJ_kF+bd#}1{v$GaQg#IEFf}jXvhCT<}Bc*FfF!-Nyzn=lOjw*A3n8SEs zm)mI-Y&%JL^3|xu_M9ho!wK^pvxFUA=a`gi+0mPp-UcuQn$v;Df*(b^6t!kwmcbmn?G1M3tM#2 zPQ0>Z>z>}Xul(D;Dm-U<>drlUmoew5lXvdSo^q4L%Kk9GO`8k=JxBWu|%)P5u4 z#vW78^^ca#v>FPZO^)A-9!j~f_}#?Wt!47#3%~Aqe@|9-)JwIeQlCk*cli&dCz)n0 zC*QcYXPJ)8`N#>vFNJ(z2*D7-Ve`xb?v$C?|y)+LGA-B7hWj@ZC53L_9`$frCFz4 z&Tvi(FZbD9pzk0kN#}DhY$-3o7QR?;Xk~X>T4k`nX=VAO2{pOW_!1$b%FX9iWtrKk zQdYysbjhJfJ{l0%d69vAcALXP`?RtEFAbh0vqA<3AY!RjR$$78)0}P|R?3xf6fyXO z3S5>P3MaWaE1jcHAEW>yt*k^8U9>{s^?K!ALhf`ID=>{lqd;*5jw1kpcq$zt<3k*t zIEi9_L(h9yx8M>5rvsKa8H=-A)XHSQ4-ds>cbQDX^bXIU3P2Bqk8vq5IjXSR6{BZ( zL_-B284TzrXL!tDmnw32kF(s(@`eiDA;yiSSZp+94>L$96$^G(ASoc;n8i4D80RW? z+X5JlRq!_64oE#9K5PtL6s#j+jfqY21kxED2v}~Ie++sk_W&56OeR|IWXq*Rje4z2 zikIe`tiaKMN2`)2G%T({a23NNN;Qcgj1^}PwN;HPDa=X`BsPl5=pV4L_;WXM9r&6HKpQJIHL(rNp+x8vW;39E=NZ!*)~SBI^A}y%*3$pvfL4mS+MiD zA|t7WsZmr-Xh>3xk|aeDBcMFq?ExJpkz%NvPz5|3OQ!=$26T>KXNq}+%TXL~NOhq> zHb7ZMYE-}+u!CgiG&j$PPPf_Vv}t8hu&_iq>^6b@#4#eHXG9*XhT;T`VKh#dF`One zG)5+(7>$m?J2}Bx`M=Q8?tzmAYMvo@!1|Q|)4-O><;w;}14Ek-*h?@R*cCLx4y52= zDtImsC*T@zu_cV7m=DaAlXpcUxPfL3tAKndrMg?meQsXjn41jCRK#ngj}DF!oENTuA&bRoFHJ3>#u!4(x1!QLaQ!wHqvGWU;<7xngrzwqI1 z;&4L*cb%y^=lb$OetN_Aw}p9qt8;VjS6}GA*k2z}EX!;DXmWf<|9f>Yszd3xK50dW zH#Q1uoE5$)W@?e|Q)${CoVsfK*Oh(#^$FA4Y>nrl#z zDz513r&^nzyLhR;^mJK&{5=1R53X+OzN$Ao9sByfYQlAzdt~lo&|CYspt=P?u^>;# MXvosPo4Tgvzbn5rhyVZp literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/quickiepowdershovel.png b/src/main/resources/assets/quickiemod/textures/item/quickiepowdershovel.png new file mode 100644 index 0000000000000000000000000000000000000000..9a8627332dd2117c1eb96a4347be4bfc11d61e7e GIT binary patch literal 4404 zcmeH~eNYp38plJcP~I#SdZJQXf?5$a+0BM*vPYnS1QL6ZS1UM(Y<7Qvg}jk0B+#S0 z)HhJ8$kiJdMLS-(dhI!09a~#^pjA)DqOIfHT|L@UWN!3C+m3Je*5-bj@Y?Il4KvsO z*qP1lKEG!_&+~kL&+j+cmYkJY;UNn`L?ThRL9fk&*9hT!CJ_EEy5ptcXx^;NY z&>?T{-tQ_RJ}7>7q;7Md8K!y|Ao+^;||q zjv*sstR7g!?)o;h{zOjHhU|RZh1S<+>tdPQt@+RX#XeSna6#+h32bikQ{#Qt{f|QEPv9^6}2}EzygL|9QIh+n8^9o{hKxx{F@G zU%F@|-rT&Uc3}rJSF;W##`aZ7jwXHAf2d>SxyVf|r_vWDTKikOGgFK) zxygHOZ`gWz`8D+Xnvc$Q*597D(fR1C?C%FMcN`P%LNx1}m#TfEyMIsNv zivNu^ygjG?wVfrETwDCUhJ{Cu+PJf^j*p%WQ_p`tp(k(0iZj=mMu`Dy1{Jr~|Af_+!V!Tu^V{)%Gk zRte48O+ezYI$-08L@8+=2hCIh9x;J3&ZZWB+tVjTI94rQoovL6jto%F>Fb;zziwp# zQ&-8TSaDivNQ#Go04v~W#ACJCT$D#G_HikAFPNob#OK0Ss>OxI93;c;1c+QBmtd&Q z!_~;dsUb*;lQmO$+RRY|d{T?cdEP-urEa%d;wB_^XPFdNsZ>%-CY8xh=z+RwZ9MHk zZLW9$;b&-pi*a%ep0nE!fk~U})x26PhU3UsepZLkIF7fuMpb}%NIkSeic2u5)heC* zhKtwLK*(r9Klz5M04`H$9&p*Koea>`02?1a8Iff$=8O}BlFB%%!&ej(Z%Qzh8TWHk zJ1ssRmXQJrutKN{=7&%5=Q;C)SW|KnMttQ=P6UP<=TGq-tKH`ey^KamYiFv3pa!j4 zEaXeEc7|gq->q3rB$Eo02_;MzgUSIQP?d=$QC1-{GdKX4OioNf8Eh_|wlP3JLAZp2 z9EJd9T1n$5#xf>UPGT5J%S|jwCgY@;WK2pEz$YQHogC~++A=vS0mVX;8D}v9kV+Wd z1W>t&k)tNLS%zW^lbkHaNE54Kd?;ZaC{2z*EtW~J2}_QJ=FN7eRV_Bs43eEcF;c); zK|W6ls^Kt0l29oK1xb?03V(S%;48rCf*mJ7aZExee6O<%l?jnF>>SQYmjS86R^}TJ z=7oaQKxJv6Q6br9hs97CPC)Z^XMx>rQHupOA|S_yjc`4&G*4@39>8drjG%Cwk`V>C zjFMv%Ay33`3Y+9_XE}52|MC`A50c`ab3NyR@oRl1|B}iFRsJXcqlNRWB?R%U3W{d@ zCAjDs!20rpEdLNwPTR@=+&)J8bce3ihW@D`c5}3KOO#<1Pon{6NJ}97iV>6Vw zr%3-xloX%Cq-_Si=eNP_3+{%}@$GO_G-2cU8IRG)_!%QW^h}Ux={qCWj9k-FU|P;I z-8CcEv=o?@^GtXB-{cCJ_@Dwd_&3N6KbO|s>&D@yR-ozSEUic(dR0UpA&{le670|y zxkRGSNZ||+b?%Oa#vtBc)CFA&ofo=naYSPs2~7hAt)@Wv8B-cveoWtLstRuLV)s9r zCykyT9UWb$zhI%>ZX6sKem1NxwVp1$zV43qUt8vFO*&a||4XuEaNymMFyZLGX>q8U z1NAEm-*5l*$8Cd;hXuPAf6}i#(|GOkF1&;sF_jJt(O078vR9&>FIDa#0%8MaHT}Nh zy7xSP&%40+l{c{=_VM7~v80TjhI-v9sr literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/quickiepowderwaterhoe.png b/src/main/resources/assets/quickiemod/textures/item/quickiepowderwaterhoe.png new file mode 100644 index 0000000000000000000000000000000000000000..4629099fdf5b8a9337dfc8287048ae93f94b621d GIT binary patch literal 4436 zcmeHKeNYo;8V_Q@@+F+i2`8sZJP*G%*(4j1YzYuZfLH?&@PrmDo81lWk&kt=kiZOO zP@o{rTz-FTYUJ7F_m9!N_sjmW)0X;0_}jHR zN#Xm#e=&7i?-qz_hUyJ&C!o={S__1Yo2eN~MLv^D9fma2cm}t}| zCeG9YsyI>lx;mxP7+RT@p}TQl|8u&CeVI{h?^F}-CxmRScAKjvr2_4O^FUzpMD`h{tU!gTJCqW&d0ff72>E zQeAs|=)F7N9M~O@UYFoLPW9;1e{yMXaIM#+K3#Fc_2Y! z+k=nOBFwt%4Y5&gBJXPYlRwz9wtcVY!qz7}XO5@#u6nKJTEdzw)}8~Wl41-IJLF9x zl?S^vKZHMf>BH-dr6a4W*k{+Jx8F^2cL*CGO~t;=+ctJ4y;0N@>c0v5&G^`Bx$Rm} zWzGhK-P*D&@a&-P?ab0Zn`yVExYahH^zb%p)uoIm>OLr+VGly$41v4EUMaM{~I zJ+B_#T|mFSzNKu_(@HeW1JsZ?S_DwaxNfPfvvHV${eHphCNVv0jc zIS7_!INEN5cuw48FXYrhA@D;p`B@o*VV2(Jm{tMkA$H-6SRz8iR;zga6An&S1W2Y6 z`oSk0nP8iW(Qx5oP1n&!#9I)IBxZ3;A#3qqNJ30m zC@Ua!fczv2@EmQP6Kg?kyvI|{{6s*wS^fp+nc6*IfHD{`t(_?3gX*ECzG~P863{5 zCQ%@WLZ(tl<+A8#8LFHE{fc58pyPN_2_lk3dpsn8B>_qtbPjFB^C>Z7%lA0=b-_S2 zKv|q`RKV=9gJQ5mmcltZn`yUO)IvU4h^L%&8^C@daSqqw90j5wQW++ZU{YD8M2ewu zaIpoEV8}eYoutjh{|n9U9w=sN%~NOxh+ph6O>L?H{D>6Q=g-HpcD#8S-2wVZNRdt(bVaVlh88W=f6` z|CcB+9>BaY1D>0*f$;^Vp?G#2PK(A5o*(fyy%;}Y1VFtMWKsGq$+aZcq7+yZc&WRV z@TuivdNElmUAk((d2VDCgMtc_fhW5433>be1N${o@c;k- literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/speedpowderaxe.png b/src/main/resources/assets/quickiemod/textures/item/speedpowderaxe.png new file mode 100644 index 0000000000000000000000000000000000000000..c933955880433ce6f4b98483166fb18fea72cde3 GIT binary patch literal 4399 zcmeHKeNYtV8DByR7Q{lZ6IzI_M-oKcyWPFxZg0bZ2M2P>!Filj3=;Qt--8X@2YU;5 zkf4czMvR|S6B$rUq6r;iI^t)sVj>^bV#GR0YaBJ|R7NEwgK0~(hQ51zPcqYCrumPX z+1uUc`R(s{p5Obt&+Kk8XDtc~`BeylAYsM~g9V<$rDIwU{Ga`Bkb$SR3hN5d!gx`) z;Ii|@02RyK00lnYjv&4-9cKNEz&X=SKdwm%h_Sx5_1g6pp6K_zoLADUZm5cgQp#=( zoPPP%<%ryM@4tKMZe~!Eg>5$QjSXGT#l5Om=03Xh^t;Da$E7!2?Yoq8<#yY}Bck%p zAB0|;XDwO#gy`Sc9apov*J-^ztz=qnkmI$@!so)^r)AwC&qmPu>uiv&6zH4&|;l zH}C2F?O*>{)mN>Xw|MTk^xu><%nXgEw>=)%xT@74 zug-fO7Zx-=6?Wu7@ZkEJ&Byw4YV$2~XNYI0&pM;JkA!yek*>T?G&OYlSJ3W?c?B!?|og z?sK?d;~_|5vd_)1ML?N=a+Ms%(tLawDN71L z69vvrTMX&L6!1Z z01qqhZjpC6QHhhWxk^QyOa}evNPZ5t$uvsu^bD&2^-%a2w}O!43Wq~6{t1tmRt8Ci z6Z*j?JXW|(6&B!el?p6KD+5k3c09!*qsctVAeB_WJKX-Fpm-C4aqKA0T`Cm&F&wJ^ z#lQhcJup9F0$$|pV`5FnP4f858J`FYH_AT&JyN?L3{fT%ZE&%rQc$BoCzJA}ITy=w zwEt2|YVCkilbBYmAu$z0DlrDI1ZGodNJ_;ekaiV0j>_oth>Vj35)~wu^N`2R5eaG) ztHJD~l7keu4bxIeEv8lhl^Up^L8}@^kuC7BE1BZ)SxHnJq|$0QwML6`7)w$x8#Qag zC;)62sa9$z%7#;9g56Igtplw$8+9^Lj*nT)#f)fo2@aji#IR^~&X~u_J3x-eNU9MU z9M`CDLWyfAT!|-)fqo4H59~OJl)&Xmwco?BbULJDVCV1-rT{41&H}$fS{E8t1C?c@ zMup6NJ1mAy6#yf;1gpzctdmK}q7vn(+XVL$$B2x95dn;blS-N(Xi{km?hf44;Wq|YN z3Au(`Y$4+;0C0Q^_v?tA|AAg0aW$Sm*#Ybyih{kMW-*4LG#JMyH8`aNS{rMd$nJ63 zMK2=&eF4-FY6bh#uN69XXbIyd!o7t+S|6wwMiAKd6;ljXtdOS0NXdzc?}?J=2aFpt z@VOxy9A9u6Dn`fQuxQfY`4NA^i}52yfYeh#CZ+F`TvKvQN`Xm%r@CuOu1P5{DezQx z{omvY8T+6DPWT$+g`Z36hQX`wQ!B`}WRU^+7zsv#x6j6BLCeqF8Mz(=35}GF0Hm%y z3L1k&qbV)8C-j+6oU~^zPll#1j0U}x`cwOkOCbSEXLhtI@9jQB9O&3tmswlAC2rxx zKwrS#voHDr@;f8n+0?c&{y=Vh)2ral%B7!{zBh2Z=W%7v>~BJ=*EFUkcVBu%8%=Gk zFn1LO(z)1q`m2y7_PO@(%j-LdbJwE}y)&okEZ%=~84{rvHpD8e9aMaElc!@rR$t}8 zU({_e2fiNuRAjxY_N~S8!zbLC0S`gS-~Ka$0o%S~!gdi{$3OcX9IdHH{P5oImv?`B z!}!9<`*(>Ymg3|62ezGgagSc=2@Z?x^9)3bh!zruR F{TIY6I#d7v literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/speedpowderhoe.png b/src/main/resources/assets/quickiemod/textures/item/speedpowderhoe.png new file mode 100644 index 0000000000000000000000000000000000000000..87e0627d1d1625b2f73d4c1c240f0ca1a019b02a GIT binary patch literal 6016 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/speedpowderpickaxe.png b/src/main/resources/assets/quickiemod/textures/item/speedpowderpickaxe.png new file mode 100644 index 0000000000000000000000000000000000000000..6a7a71d3824a395f895272c4c69cad135787c6cb GIT binary patch literal 4409 zcmeHKeNYtV9bRe*5l%~mPM{#JheS~J_T#=+P6Y0Nlbj%66oU+VyL-om`&jQ5?qG^E zh(?GO0x=n=ALtmSNo`Ct8BtO+A|bV?ajcDvwpgpRModyo{DN|Q_YM#zndvao{Kw7Q z?Y_VF+2{TJp5ODnbK8)&B5PLY&qE;ynq|z^=Ywmw_GZ$vIhuPcb_-&4NucJPwX=ZwE4PS1I^AwFWx zy|cqVi<`R=x!98PcG67h!izRZqvZXKtAB?@{Ac7 z;{|~-cGSG8%kIsK+>~2jIM=xG$A;Lt!iC+x*+Ty={iloS*X~&r()z||TI=QoeSIr= zMDyU#nhJjXpD%p0D*UP1WyR}uM6TO+a=0b^m8f~ef9tRMD)!6npM-zGb{5UWmz}rE zw{Ll+ZRqWb-!_&=^0%cox3L4p{5d_hZp8)l3>vCl_x(O~_3rjVQQ_eY^Z;hRI_qki z>C%-Cb7L)rqJ*UjcVTa(UCnxDaon->vaaN>2i|R4aXRAVhQ9Qe#rA>5&dd~3>`LX% zJDaxlFS>!8S$pJEd(E9^HoG33B0hU7v-!C6bvUiQZqf3@-pto3cSeRKkxj!7US4-h zFWXd{fVq-8el+Xgtq|YF!9yS1DQGRpPn<3EXwLLUefmL|;>BOxtr^m6i+~?Uifd^P87{a^t1@@<*M?7$5e{{wjC*u77+J zlzo1Gi~9IS^RbeSp^Due&*8JT2bY|F_#enJ!?maT-1Z`1ylM^@Y>nwTl6Kl<6yr3r zGOwKn&V!(oR4-4_<*WdkSu5wzNx$koCWSdhCta;HVJ1F%}G3^91QN2r9qus|fF7uq;!#|Np>{hu`3bjRs01Wq z34QMq?n1Cn(R|kJtZ>n+p^|k7@slaCjHbK^2C*b7XXpJz0r8$#jG-rRe1*&A$1pU? z+E_avb%XryC-4Gic`ViwxrsCWawaDNmYd*z0zF>49}G|?6RCI772={sy-q6TOEONH zV@UrkO=uKyB|{;&T1g`c6|O=kv&w?d7Beo_GK5;q$|q479d3bg(5y%W$YmVhF)J;s zg3!>2Mx_N58r+OfYApd68M7KwQYwOACQ;Qlr9^N|p98=y}%V296U+aZDyx`DYlK%mkDaa1LjutSrhqto{kHFC?f2 zC`*Y(1VatY7611-4WHyFM@q3~ii$FTt>XSCAAPD8Wrt zvVm>^uD}#sMmel3I6lVwIv(e~#|v^f!78DLNQ474!GFWLm$Q^tz@0g53wj(k@!bgW`jJT=BkPC>sT zN{Sya>6ih}1!Ca%0;eH5aU70`1~T{|KV!}KA(w#R=|!fb@3dUga!pBrDS@ZmH7(ba z6qpit+Fk!Qxk4YmP_Yj1H^>8Cm*~jPZQxZa*qoE4hYmm?P)PGUEDl6w^4Udh2nvf3 zzd=y@jwlce5sW57$c?aP!q8{mJG<>N2n`zbX@#0U(xp*l$G7C9FMs}C>d}jb`kSH~ zh-F~l`_t+JQTprGqMk}v;J=FZ``$>VO08Ba|JkEHj6NTq*;0JG@5~u~iQ=`i%72@K z<2vt4)NwWJft2#k#`UwwxO( zO+3k8Iq|~gn5G_L!|=n_zkl1CCD9*&EO$q4=jM%!j9z!22=2JFHTnK%U(QJIm4ng2 zC8^c*gMZn1^9!HyT9+>(qHpU(+sFU3?cLkheA=6~d3Wr?_M{-_%Wk&Gw$saiQX!*Z Lh5nuN(z^cw@uoqj literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/quickiemod/textures/item/speedpowdershovel.png b/src/main/resources/assets/quickiemod/textures/item/speedpowdershovel.png new file mode 100644 index 0000000000000000000000000000000000000000..b1a4458264578ea7fe276033cb32a05af8124869 GIT binary patch literal 4417 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.15.11", "minecraft": "~1.21", diff --git a/src/main/resources/quickiemod.mixins.json b/src/main/resources/quickiemod.mixins.json new file mode 100644 index 0000000..f2859fb --- /dev/null +++ b/src/main/resources/quickiemod.mixins.json @@ -0,0 +1,14 @@ +{ + "required": true, + "minVersion": "0.8", + "package": "de.jottyfan.quickiemod.mixin", + "compatibilityLevel": "JAVA_21", + "mixins": [ + "BlockBreakMixin" + ], + "client": [ + ], + "injectors": { + "defaultRequire": 1 + } +} \ No newline at end of file