Merge pull request #936 from L-Lawlite/1.21.1

1.21.1

Author: mrh0

src/generated/resources/data/createaddition/recipe/charging/channeling.json

@@ -0,0 +1,19 @@
+{
+  "type": "createaddition:charging",
+  "energy": 10000000,
+  "ingredient": {
+    "item": "minecraft:book"
+  },
+  "max_charge_rate": 1000,
+  "result": {
+    "components": {
+      "minecraft:stored_enchantments": {
+        "levels": {
+          "minecraft:channeling": 1
+        }
+      }
+    },
+    "count": 1,
+    "id": "minecraft:enchanted_book"
+  }
+}

src/generated/resources/data/createaddition/recipe/charging/copper_block.json

@@ -0,0 +1,12 @@
+{
+  "type": "createaddition:charging",
+  "energy": 4000,
+  "ingredient": {
+    "item": "minecraft:exposed_copper"
+  },
+  "max_charge_rate": 200,
+  "result": {
+    "count": 1,
+    "id": "minecraft:copper_block"
+  }
+}

src/main/java/com/mrh0/createaddition/datagen/CreateAdditionsDataGen.java

@@ -35,7 +35,6 @@ public static void gatherData(GatherDataEvent event) {
         generator.addProvider(event.includeServer(), blockTags);
         generator.addProvider(event.includeServer(), new CAFluidTagProvider(output, lookupProvider, existingFileHelper));
         generator.addProvider(event.includeServer(), new CAItemTagProvider(output, lookupProvider, blockTags.contentsGetter(), existingFileHelper));
-//        generator.addProvider(event.includeServer(), new CALootTableProvider(output,lookupProvider));
         generator.addProvider(event.includeServer(), new CACraftingRecipeProvider(output, lookupProvider));
         generator.addProvider(event.includeServer(), new CACrushingRecipeGen(output, lookupProvider));
         generator.addProvider(event.includeServer(), new CACompactingRecipeGen(output, lookupProvider));
@@ -44,6 +43,8 @@ public static void gatherData(GatherDataEvent event) {
         generator.addProvider(event.includeServer(), new CAMechanicalCrafterRecipeGen(output, lookupProvider));
         generator.addProvider(event.includeServer(), new CAPressingRecipeGen(output, lookupProvider));
 
+        generator.addProvider(event.includeServer(), new CAChargingRecipeProvider(output,lookupProvider));
+
         generator.addProvider(event.includeServer(), new DatapackBuiltinEntriesProvider(output, lookupProvider, new RegistrySetBuilder()
                 .add(Registries.DAMAGE_TYPE, CADamageTypesDatagen::bootstrap)
                 .add(CreateRegistries.POTATO_PROJECTILE_TYPE, CAPotatoProjectileTypesDatagen::bootstrap),

src/main/java/com/mrh0/createaddition/datagen/LootTableProvider/CABlockLootTableSubProvider.java

@@ -0,0 +1,110 @@
+package com.mrh0.createaddition.datagen.RecipeBuilders;
+
+import com.mrh0.createaddition.CreateAddition;
+import com.mrh0.createaddition.recipe.charging.ChargingRecipe;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.data.recipes.RecipeOutput;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.enchantment.Enchantment;
+import net.minecraft.world.level.ItemLike;
+
+import java.util.Objects;
+
+public class CAChargingRecipeBuilder extends CARecipeBuilder {
+    protected Ingredient ingredient;
+    protected int energy , maxChargeRate;
+
+    public CAChargingRecipeBuilder(ItemStack result) {
+        super(result);
+        this.ingredient = Ingredient.EMPTY;
+        this.energy = 0;
+        this.maxChargeRate = 0;
+    }
+
+
+
+    public static CAChargingRecipeBuilder charging(ItemStack itemStack) {
+        return new CAChargingRecipeBuilder(itemStack);
+    }
+
+    public static CAChargingRecipeBuilder charging(ItemLike result, int count) {
+        return charging(new ItemStack(result,count));
+    }
+
+    public static CAChargingRecipeBuilder charging(ItemLike result) {
+        return charging(new ItemStack(result));
+    }
+
+    public static CAChargingRecipeBuilder charging(Item result, int count) {
+        return charging(new ItemStack(result,count));
+    }
+
+
+    public static CAChargingRecipeBuilder charging(Item result) {
+        return charging(new ItemStack(result));
+    }
+
+    public static CAChargingRecipeBuilder charging(ItemStack item, ResourceKey<Enchantment> enchantmentKey, HolderLookup.Provider provider) {
+        item.enchant(provider.holderOrThrow(enchantmentKey),1);
+        return charging(item);
+    }
+
+    public CAChargingRecipeBuilder require(Ingredient ingredient) {
+        this.ingredient = ingredient;
+        return this;
+    }
+
+    public CAChargingRecipeBuilder require(ItemLike item) {
+        this.require(Ingredient.of(item));
+        return this;
+    }
+
+    public CAChargingRecipeBuilder require(ItemStack item) {
+        this.require(Ingredient.of(item));
+        return this;
+    }
+
+    public CAChargingRecipeBuilder require(ItemLike item, int count) {
+        for(int i=0; i< count; ++i) {
+            this.require(Ingredient.of(item));
+        }
+        return this;
+    }
+
+    public CAChargingRecipeBuilder energy(int energy) {
+        this.energy = energy;
+        return this;
+    }
+
+    public CAChargingRecipeBuilder maxChargeRate(int maxChargeRate) {
+        this.maxChargeRate = maxChargeRate;
+        return this;
+    }
+
+    @Override
+    public void save(RecipeOutput recipeOutput, ResourceLocation resourceLocation) {
+        ChargingRecipe chargingRecipe = new ChargingRecipe(
+                Objects.requireNonNullElse(this.group,""),
+                this.ingredient,
+                this.result,
+                this.energy,
+                this.maxChargeRate
+        );
+        recipeOutput.accept(resourceLocation.withPrefix("charging/"), chargingRecipe, null);
+    }
+
+    @Override
+    public void save(RecipeOutput recipeOutput) {
+        save(recipeOutput, BuiltInRegistries.ITEM.getKey(this.result.getItem()));
+    }
+
+    @Override
+    public void save(RecipeOutput recipeOutput, String id) {
+        save(recipeOutput, ResourceLocation.fromNamespaceAndPath(CreateAddition.MODID,id));
+    }
+}

src/main/java/com/mrh0/createaddition/datagen/LootTableProvider/CALootTableProvider.java

@@ -0,0 +1,38 @@
+package com.mrh0.createaddition.datagen.RecipeBuilders;
+
+import net.minecraft.advancements.Criterion;
+import net.minecraft.data.recipes.RecipeBuilder;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public abstract class CARecipeBuilder implements RecipeBuilder {
+    protected final ItemStack result;
+    protected final Map<String, Criterion<?>> criteria = new LinkedHashMap<>();
+    @Nullable protected String group = null;
+
+    public CARecipeBuilder(ItemStack result) {
+        this.result = result;
+    }
+
+    @Override
+    public RecipeBuilder unlockedBy(String s, Criterion<?> criterion) {
+        return this;
+    }
+
+    @Override
+    public RecipeBuilder group(@Nullable String group) {
+        this.group = group;
+        return this;
+    }
+
+    @Override
+    public Item getResult() {
+        return this.result.getItem();
+    }
+
+
+}

src/main/java/com/mrh0/createaddition/datagen/RecipeBuilders/CAChargingRecipeBuilder.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@MethodsReturnNonnullByDefault
+package com.mrh0.createaddition.datagen.RecipeBuilders;
+
+import net.minecraft.MethodsReturnNonnullByDefault;
+
+import javax.annotation.ParametersAreNonnullByDefault;

src/main/java/com/mrh0/createaddition/datagen/RecipeBuilders/CARecipeBuilder.java

@@ -0,0 +1,75 @@
+package com.mrh0.createaddition.datagen.RecipeProvider;
+
+import com.mrh0.createaddition.CreateAddition;
+import com.mrh0.createaddition.datagen.RecipeBuilders.CAChargingRecipeBuilder;
+import com.mrh0.createaddition.index.CARecipes;
+import com.simibubi.create.foundation.data.recipe.ProcessingRecipeGen;
+import com.simibubi.create.foundation.recipe.IRecipeTypeInfo;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.data.PackOutput;
+import net.minecraft.data.recipes.RecipeOutput;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.item.crafting.RecipeInput;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraft.world.item.enchantment.Enchantments;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class CAChargingRecipeProvider extends ProcessingRecipeGen {
+    public static final IRecipeTypeInfo recipeType = new IRecipeTypeInfo() {
+        @Override
+        public ResourceLocation getId() {
+            return CARecipes.CHARGING.getId();
+        }
+
+        @Override
+        public <T extends RecipeSerializer<?>> T getSerializer() {
+            return (T) CARecipes.CHARGING.get();
+        }
+
+        @Override
+        public <V extends RecipeInput, R extends Recipe<V>> RecipeType<R> getType() {
+            return (RecipeType<R>) CARecipes.CHARGING_TYPE.get();
+        }
+    };
+    private final HolderLookup.Provider provider;
+
+    public CAChargingRecipeProvider(PackOutput output, CompletableFuture<HolderLookup.Provider> registries) {
+        super(output, registries);
+        try {
+            this.provider = registries.get();
+        } catch (InterruptedException | ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected void buildRecipes(@NotNull RecipeOutput output) {
+        CAChargingRecipeBuilder.charging(Items.COPPER_BLOCK)
+                .require(Items.EXPOSED_COPPER)
+                .energy(4000)
+                .maxChargeRate(200)
+                .save(output, ResourceLocation.fromNamespaceAndPath(CreateAddition.MODID, BuiltInRegistries.ITEM.getKey(Items.COPPER_BLOCK).getPath()));
+        CAChargingRecipeBuilder.charging(new ItemStack(Items.ENCHANTED_BOOK), Enchantments.CHANNELING, provider)
+                .require(Items.BOOK)
+                .maxChargeRate(1000)
+                .energy(10000000)
+                .save(output, ResourceLocation.fromNamespaceAndPath(CreateAddition.MODID, Enchantments.CHANNELING.location().getPath()));
+//        CAChargingRecipeBuilder.charging(AllBlocks.COPPER_SHINGLES.get( CopperBlockSet.SlabVariant.INSTANCE, WeatheringCopper.WeatherState.UNAFFECTED,false).asItem());
+
+    }
+
+
+    @Override
+    protected IRecipeTypeInfo getRecipeType() {
+       return recipeType;
+    }
+
+}

src/main/java/com/mrh0/createaddition/datagen/RecipeBuilders/package-info.java

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+	  "name": "createaddition:electrum_block",
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "createaddition:electrum_block"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ]
+}