PonyMirrors/Unicopia
1
0
Fork 0
mirror of https://github.com/Sollace/Unicopia.git synced 2024-11-23 21:38:00 +01:00
Code Issues Projects Releases Packages Wiki Activity

Move all remaining regular recipes to datagen

Browse source
This commit is contained in:
Sollace 2024-03-22 00:07:36 +00:00
parent 1e8b6ebaab
commit a3c1248e9f
No known key found for this signature in database
GPG key ID: E52FACE7B5C773DB
188 changed files with 681 additions and 3498 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/main/java/com/minelittlepony/unicopia/UTags.java
View file

@ -36,6 +36,7 @@ public interface UTags {
TagKey<Item> BASKETS = item("baskets");
TagKey<Item> BADGES = item("badges");
TagKey<Item> WOOL_BED_SHEETS = item("wool_bed_sheets");
TagKey<Item> BED_SHEETS = item("bed_sheets");
TagKey<Item> CLOUD_JARS = item("cloud_jars");

1
src/main/java/com/minelittlepony/unicopia/block/FancyBedBlock.java
View file

@ -127,6 +127,7 @@ public class FancyBedBlock extends BedBlock {
public enum SheetPattern implements StringIdentifiable {
NONE(DyeColor.WHITE),
WHITE(DyeColor.WHITE),
LIGHT_GRAY(DyeColor.LIGHT_GRAY),
GRAY(DyeColor.GRAY),
BLACK(DyeColor.BLACK),

2
src/main/java/com/minelittlepony/unicopia/client/render/entity/CloudBedBlockEntityRenderer.java
View file

@ -100,7 +100,7 @@ public class CloudBedBlockEntityRenderer implements BlockEntityRenderer<CloudBed
false,
false
);
if (pattern != CloudBedBlock.SheetPattern.NONE) {
if (pattern != CloudBedBlock.SheetPattern.NONE && pattern != CloudBedBlock.SheetPattern.WHITE) {
renderModel(matrices, vertices,
state.get(BedBlock.PART) == BedPart.HEAD ? bedSheetsHead : bedSheetsFoot,
state.get(BedBlock.FACING),

65
src/main/java/com/minelittlepony/unicopia/datagen/CraftingMaterialHelper.java Normal file
View file

@ -0,0 +1,65 @@
package com.minelittlepony.unicopia.datagen;
import java.util.Map;
import java.util.NoSuchElementException;
import com.mojang.datafixers.util.Either;
import net.fabricmc.fabric.api.tag.convention.v1.ConventionalItemTags;
import net.minecraft.advancement.criterion.InventoryChangedCriterion;
import net.minecraft.data.server.recipe.RecipeProvider;
import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
import net.minecraft.data.server.recipe.VanillaRecipeProvider;
import net.minecraft.item.Item;
import net.minecraft.item.ItemConvertible;
import net.minecraft.registry.Registries;
import net.minecraft.registry.tag.ItemTags;
import net.minecraft.registry.tag.TagKey;
import net.minecraft.util.Identifier;
public interface CraftingMaterialHelper {
Map<String, TagKey<Item>> MATERIALS = Map.of(
"wood", ItemTags.PLANKS,
"stone", ItemTags.STONE_TOOL_MATERIALS,
"iron", ConventionalItemTags.IRON_INGOTS,
"gold", ConventionalItemTags.GOLD_INGOTS,
"copper", ConventionalItemTags.COPPER_INGOTS,
"netherite", ConventionalItemTags.NETHERITE_INGOTS
);
static Either<ItemConvertible, TagKey<Item>> getMaterial(Item output, String toStrip, String suffex) {
Identifier id = Registries.ITEM.getId(output).withPath(p -> p.replace(toStrip, "") + suffex);
TagKey<Item> tag = MATERIALS.getOrDefault(id.getPath().replace("en_", "_").split("_")[0], null);
if (tag != null) {
return Either.right(tag);
}
return Either.left(
Registries.ITEM.getOrEmpty(id)
.or(() -> Registries.ITEM.getOrEmpty(new Identifier(Identifier.DEFAULT_NAMESPACE, id.getPath())))
.or(() -> Registries.ITEM.getOrEmpty(new Identifier(Identifier.DEFAULT_NAMESPACE, id.getPath().replace(suffex, ""))))
.orElseThrow(() -> new NoSuchElementException("No item with id " + id))
);
}
static Item getItem(Identifier id) {
return Registries.ITEM.getOrEmpty(id).orElseThrow(() -> new NoSuchElementException("No item with id " + id));
}
static ShapedRecipeJsonBuilder input(ShapedRecipeJsonBuilder builder, char key, Either<ItemConvertible, TagKey<Item>> material) {
material.ifLeft(i -> builder.input(key, i));
material.ifRight(i -> builder.input(key, i));
return builder;
}
static InventoryChangedCriterion.Conditions conditionsFromEither(Either<ItemConvertible, TagKey<Item>> material) {
return material.map(RecipeProvider::conditionsFromItem, RecipeProvider::conditionsFromTag);
}
static String hasEither(Either<ItemConvertible, TagKey<Item>> material) {
return material.map(VanillaRecipeProvider::hasItem, CraftingMaterialHelper::hasTag);
}
static String hasTag(TagKey<Item> tag) {
return "has_" + tag.id();
}
}

20
src/main/java/com/minelittlepony/unicopia/datagen/UBlockFamilies.java
View file

@ -19,4 +19,24 @@ public interface UBlockFamilies {
.slab(UBlocks.WAXED_ZAP_SLAB).stairs(UBlocks.WAXED_ZAP_STAIRS).fence(UBlocks.WAXED_ZAP_FENCE).fenceGate(UBlocks.WAXED_ZAP_FENCE_GATE)
.group("wooden").unlockCriterionName("has_planks")
.build();
BlockFamily CHISELED_CHITIN = new BlockFamily.Builder(UBlocks.CHISELLED_CHITIN)
.slab(UBlocks.CHISELLED_CHITIN_SLAB).stairs(UBlocks.CHISELLED_CHITIN_STAIRS)
.group("chitin").unlockCriterionName("has_chiselled_chitin")
.build();
BlockFamily CLOUD = new BlockFamily.Builder(UBlocks.CLOUD)
.slab(UBlocks.CLOUD_SLAB).stairs(UBlocks.CLOUD_STAIRS)
.group("cloud").unlockCriterionName("has_cloud_lump")
.build();
BlockFamily CLOUD_PLANKS = new BlockFamily.Builder(UBlocks.CLOUD_PLANKS)
.slab(UBlocks.CLOUD_PLANK_SLAB).stairs(UBlocks.CLOUD_PLANK_STAIRS)
.group("cloud").unlockCriterionName("has_cloud")
.build();
BlockFamily CLOUD_BRICKS = new BlockFamily.Builder(UBlocks.CLOUD_BRICKS)
.slab(UBlocks.CLOUD_BRICK_SLAB).stairs(UBlocks.CLOUD_BRICK_STAIRS)
.group("cloud").unlockCriterionName("has_cloud_bricks")
.build();
BlockFamily DENSE_CLOUD = new BlockFamily.Builder(UBlocks.DENSE_CLOUD)
.slab(UBlocks.DENSE_CLOUD_SLAB).stairs(UBlocks.DENSE_CLOUD_STAIRS)
.group("cloud").unlockCriterionName("has_dense_cloud")
.build();
}

83
src/main/java/com/minelittlepony/unicopia/datagen/providers/BedSheetPatternRecipeBuilder.java Normal file
View file

@ -0,0 +1,83 @@
package com.minelittlepony.unicopia.datagen.providers;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Stream;
import org.jetbrains.annotations.Nullable;
import com.minelittlepony.unicopia.UTags;
import com.minelittlepony.unicopia.item.UItems;
import net.minecraft.data.server.recipe.RecipeJsonProvider;
import net.minecraft.data.server.recipe.RecipeProvider;
import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
import net.minecraft.data.server.recipe.ShapelessRecipeJsonBuilder;
import net.minecraft.item.ItemConvertible;
import net.minecraft.recipe.book.RecipeCategory;
public class BedSheetPatternRecipeBuilder {
record PatternTemplate(List<Character> symbols, List<Character> uniqueSymbols, String[] pattern) {
static final PatternTemplate ONE_COLOR = new PatternTemplate(new String[] { "###", "# #", " ##" });
static final PatternTemplate TWO_COLOR = new PatternTemplate(new String[] { "#%#", "% %", " %#" });
static final PatternTemplate THREE_COLOR = new PatternTemplate(new String[] { "cvc", "h h", " vc" });
static final PatternTemplate FOUR_COLOR = new PatternTemplate(new String[] { "wgb", "p g", " pw" });
static final PatternTemplate SEVEN_COLOR = new PatternTemplate(new String[] { "roy", "l b", " pg" });
PatternTemplate(String[] pattern) {
this(List.of(
pattern[1].charAt(0),
pattern[0].charAt(0),
pattern[0].charAt(1),
pattern[0].charAt(2),
pattern[1].charAt(2),
pattern[2].charAt(2),
pattern[2].charAt(1)
), pattern);
}
PatternTemplate(List<Character> symbols, String[] pattern) {
this(symbols, symbols.stream().distinct().toList(), pattern);
}
void offerWithoutConversion(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible...wool) {
offerRecipe(this, null, exporter, output, wool);
}
void offerTo(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible...wool) {
Map<Character, ItemConvertible> symbolMap = new HashMap<>();
offerRecipe(this, symbolMap, exporter, output, wool);
offerBedSheetConversionRecipe(exporter, output, symbols.stream().map(symbolMap::get));
}
}
private static void offerRecipe(PatternTemplate template, @Nullable Map<Character, ItemConvertible> symbolMap, Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible...wool) {
ShapedRecipeJsonBuilder builder = ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output);
for (int i = 0; i < template.uniqueSymbols().size(); i++) {
builder.input(template.uniqueSymbols().get(i), wool[i]);
if (symbolMap != null) {
symbolMap.put(template.uniqueSymbols().get(i), wool[i]);
}
}
for (int i = 0; i < template.pattern().length; i++) {
builder.pattern(template.pattern()[i]);
}
Arrays.asList(wool).stream().distinct().forEach(input -> {
builder.criterion(RecipeProvider.hasItem(input), RecipeProvider.conditionsFromItem(input));
});
builder.group("bed_sheet").offerTo(exporter);
}
private static void offerBedSheetConversionRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, Stream<ItemConvertible> wools) {
var builder = ShapelessRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output)
.input(UTags.WOOL_BED_SHEETS).criterion("has_bed_sheet", RecipeProvider.conditionsFromTag(UTags.WOOL_BED_SHEETS));
wools.forEach(builder::input);
builder
.group("bed_sheet")
.offerTo(exporter, RecipeProvider.convertBetween(output, UItems.WHITE_BED_SHEETS));
}
}

2
src/main/java/com/minelittlepony/unicopia/datagen/providers/UBlockStateModelGenerator.java
View file

@ -108,7 +108,7 @@ public class UBlockStateModelGenerator extends BlockStateModelGenerator {
// chitin blocks
registerTopsoil(UBlocks.SURFACE_CHITIN, UBlocks.CHITIN);
registerHollow(UBlocks.CHITIN);
registerCubeAllModelTexturePool(UBlocks.CHISELLED_CHITIN).stairs(UBlocks.CHISELLED_CHITIN_STAIRS).slab(UBlocks.CHISELLED_CHITIN_SLAB);
registerCubeAllModelTexturePool(UBlocks.CHISELLED_CHITIN).family(UBlockFamilies.CHISELED_CHITIN);
registerHiveBlock(UBlocks.HIVE);
registerRotated(UBlocks.CHITIN_SPIKES, BlockModels.SPIKES);
registerHull(UBlocks.CHISELLED_CHITIN_HULL, UBlocks.CHITIN, UBlocks.CHISELLED_CHITIN);

3
src/main/java/com/minelittlepony/unicopia/datagen/providers/UItemTagProvider.java
View file

@ -76,7 +76,8 @@ public class UItemTagProvider extends FabricTagProvider.ItemTagProvider {
.map(race -> race.getId().withPath(p -> p + "_badge"))
.flatMap(id -> Registries.ITEM.getOrEmpty(id).stream())
.toArray(Item[]::new));
getOrCreateTagBuilder(UTags.BED_SHEETS).add(BedsheetsItem.ITEMS.values().stream().toArray(Item[]::new));
getOrCreateTagBuilder(UTags.WOOL_BED_SHEETS).add(BedsheetsItem.ITEMS.values().stream().filter(sheet -> sheet != UItems.KELP_BED_SHEETS).toArray(Item[]::new));
getOrCreateTagBuilder(UTags.BED_SHEETS).forceAddTag(UTags.WOOL_BED_SHEETS).add(UItems.KELP_BED_SHEETS);
getOrCreateTagBuilder(UTags.APPLE_SEEDS).add(UItems.GREEN_APPLE_SEEDS, UItems.SWEET_APPLE_SEEDS, UItems.SOUR_APPLE_SEEDS);
getOrCreateTagBuilder(UTags.MAGIC_FEATHERS).add(UItems.PEGASUS_FEATHER, UItems.GRYPHON_FEATHER);
getOrCreateTagBuilder(UTags.FRESH_APPLES).add(Items.APPLE, UItems.GREEN_APPLE, UItems.SWEET_APPLE, UItems.SOUR_APPLE);

533
src/main/java/com/minelittlepony/unicopia/datagen/providers/URecipeProvider.java
View file

@ -1,72 +1,548 @@
package com.minelittlepony.unicopia.datagen.providers;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.List;
import java.util.function.Consumer;
import org.jetbrains.annotations.Nullable;
import com.minelittlepony.unicopia.UConventionalTags;
import com.minelittlepony.unicopia.UTags;
import com.minelittlepony.unicopia.Unicopia;
import com.minelittlepony.unicopia.block.UBlocks;
import com.minelittlepony.unicopia.datagen.CraftingMaterialHelper;
import com.minelittlepony.unicopia.datagen.ItemFamilies;
import com.minelittlepony.unicopia.datagen.UBlockFamilies;
import com.minelittlepony.unicopia.datagen.providers.BedSheetPatternRecipeBuilder.PatternTemplate;
import com.minelittlepony.unicopia.item.UItems;
import com.minelittlepony.unicopia.item.URecipes;
import com.mojang.datafixers.util.Either;
import net.fabricmc.fabric.api.datagen.v1.FabricDataOutput;
import net.fabricmc.fabric.api.datagen.v1.provider.FabricRecipeProvider;
import net.fabricmc.fabric.api.tag.convention.v1.ConventionalItemTags;
import net.minecraft.advancement.criterion.InventoryChangedCriterion;
import net.minecraft.block.Block;
import net.minecraft.block.Blocks;
import net.minecraft.data.server.recipe.ComplexRecipeJsonBuilder;
import net.minecraft.data.server.recipe.RecipeJsonProvider;
import net.minecraft.data.server.recipe.RecipeProvider;
import net.minecraft.data.server.recipe.ShapedRecipeJsonBuilder;
import net.minecraft.data.server.recipe.ShapelessRecipeJsonBuilder;
import net.minecraft.data.server.recipe.VanillaRecipeProvider;
import net.minecraft.item.Item;
import net.minecraft.item.ItemConvertible;
import net.minecraft.item.Items;
import net.minecraft.predicate.NumberRange;
import net.minecraft.predicate.entity.LootContextPredicate;
import net.minecraft.predicate.item.ItemPredicate;
import net.minecraft.recipe.Ingredient;
import net.minecraft.recipe.book.RecipeCategory;
import net.minecraft.registry.Registries;
import net.minecraft.util.Identifier;
import net.minecraft.registry.tag.ItemTags;
import net.minecraft.registry.tag.TagKey;
public class URecipeProvider extends FabricRecipeProvider {
private static final List<Item> WOOLS = List.of(Items.BLACK_WOOL, Items.BLUE_WOOL, Items.BROWN_WOOL, Items.CYAN_WOOL, Items.GRAY_WOOL, Items.GREEN_WOOL, Items.LIGHT_BLUE_WOOL, Items.LIGHT_GRAY_WOOL, Items.LIME_WOOL, Items.MAGENTA_WOOL, Items.ORANGE_WOOL, Items.PINK_WOOL, Items.PURPLE_WOOL, Items.RED_WOOL, Items.YELLOW_WOOL, Items.WHITE_WOOL);
public URecipeProvider(FabricDataOutput output) {
super(output);
}
@Override
public void generate(Consumer<RecipeJsonProvider> exporter) {
Arrays.stream(ItemFamilies.BASKETS).forEach(basket -> {
offerBasketRecipe(exporter, basket, getMaterial(basket, "_basket", "_planks"));
});
generateVanillaRecipeExtensions(exporter);
offerJarRecipes(exporter);
offerWoodBlocksRecipes(exporter);
offerChitinBlocksRecipes(exporter);
offerCloudRecipes(exporter);
offerFoodRecipes(exporter);
offerGemstoneAndMagicRecipes(exporter);
offerSeaponyRecipes(exporter);
offerEarthPonyRecipes(exporter);
// beds
createCustomBedRecipe(UItems.CLOUD_BED, Either.left(UBlocks.DENSE_CLOUD), Either.left(UBlocks.CLOUD_PLANKS)).offerTo(exporter);
createCustomBedRecipe(UItems.CLOTH_BED, Either.right(ItemTags.WOOL), Either.right(ItemTags.LOGS)).offerTo(exporter);
offerBedSheetRecipes(exporter);
// sunglasses
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.SUNGLASSES)
.input('#', ConventionalItemTags.GLASS_BLOCKS).criterion("has_glass_block", conditionsFromTag(ConventionalItemTags.GLASS_BLOCKS))
.pattern("##")
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.SUNGLASSES)
.input(ConventionalItemTags.GLASS_BLOCKS)
.input(UItems.SUNGLASSES).criterion("has_broken_sunglasses", conditionsFromItem(UItems.BROKEN_SUNGLASSES))
.offerTo(exporter, convertBetween(UItems.SUNGLASSES, UItems.BROKEN_SUNGLASSES));
}
private void generateVanillaRecipeExtensions(Consumer<RecipeJsonProvider> exporter) {
ShapelessRecipeJsonBuilder.create(RecipeCategory.MISC, Items.WRITABLE_BOOK).input(Items.BOOK).input(Items.INK_SAC).input(UTags.MAGIC_FEATHERS).criterion("has_book", conditionsFromItem(Items.BOOK)).offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.COMBAT, Items.ARROW, 4).input('#', UConventionalTags.STICKS).input('X', Items.FLINT).input('Y', UTags.MAGIC_FEATHERS).pattern("X").pattern("#").pattern("Y").criterion("has_feather", conditionsFromTag(UTags.MAGIC_FEATHERS)).criterion("has_flint", conditionsFromItem(Items.FLINT)).offerTo(exporter);
}
private void offerJarRecipes(Consumer<RecipeJsonProvider> exporter) {
ComplexRecipeJsonBuilder.create(URecipes.JAR_EXTRACT_SERIALIZER).offerTo(exporter, "empty_jar_from_filled_jar");
ComplexRecipeJsonBuilder.create(URecipes.JAR_INSERT_SERIALIZER).offerTo(exporter, "filled_jar");
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.EMPTY_JAR, 7)
.input('#', ItemTags.PLANKS)
.input('*', ConventionalItemTags.GLASS_BLOCKS).criterion("has_glass", conditionsFromTag(ConventionalItemTags.GLASS_BLOCKS))
.pattern("*#*")
.pattern("* *")
.pattern("***")
.offerTo(exporter);
}
private void offerCloudRecipes(Consumer<RecipeJsonProvider> exporter) {
offerShapelessRecipe(exporter, UItems.CLOUD_LUMP, UTags.CLOUD_JARS, "cloud", 4);
generateFamily(exporter, UBlockFamilies.CLOUD);
offer2x3Recipe(exporter, UBlocks.CLOUD_PILLAR, UBlocks.CLOUD, "pillar");
offer2x2CompactingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CLOUD, UItems.CLOUD_LUMP);
offerPolishedStoneRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CLOUD_PLANKS, UBlocks.CLOUD);
generateFamily(exporter, UBlockFamilies.CLOUD_PLANKS);
offerChestRecipe(exporter, UBlocks.CLOUD_CHEST, UBlocks.CLOUD_PLANKS);
offer2x2CompactingRecipe(exporter, RecipeCategory.DECORATIONS, UBlocks.SHAPING_BENCH, UBlocks.DENSE_CLOUD);
generateFamily(exporter, UBlockFamilies.CLOUD_BRICKS);
offerCompactingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.DENSE_CLOUD, UBlocks.CLOUD, 4);
generateFamily(exporter, UBlockFamilies.DENSE_CLOUD);
offer2x3Recipe(exporter, UBlocks.CLOUD_DOOR, UBlocks.DENSE_CLOUD, "door");
// XXX: Make the unstable cloud recipe shapeless and change output to 8 (to align with making jam toast)
ShapelessRecipeJsonBuilder.create(RecipeCategory.REDSTONE, UBlocks.UNSTABLE_CLOUD, 8)
.input(UBlocks.CLOUD, 8)
.input(Ingredient.ofItems(UItems.LIGHTNING_JAR, UItems.ZAP_APPLE_JAM_JAR))
.criterion("has_lightning_jar", conditionsFromItem(UItems.LIGHTNING_JAR))
.criterion("has_zap_jar", conditionsFromItem(UItems.ZAP_APPLE_JAM_JAR))
.offerTo(exporter);
}
private void offerWoodBlocksRecipes(Consumer<RecipeJsonProvider> exporter) {
// palm wood
generateFamily(exporter, UBlockFamilies.PALM);
offerPlanksRecipe(exporter, UBlocks.PALM_PLANKS, UTags.Items.PALM_LOGS, 4);
offerBarkBlockRecipe(exporter, UBlocks.PALM_WOOD, UBlocks.PALM_LOG);
offerBarkBlockRecipe(exporter, UBlocks.STRIPPED_PALM_WOOD, UBlocks.STRIPPED_PALM_LOG);
offerBoatRecipe(exporter, UItems.PALM_BOAT, UBlocks.PALM_PLANKS);
offerChestBoatRecipe(exporter, UItems.PALM_CHEST_BOAT, UItems.PALM_BOAT);
offerHangingSignRecipe(exporter, UBlocks.PALM_HANGING_SIGN, UBlocks.PALM_PLANKS);
offerPlanksRecipe(exporter, UBlocks.PALM_PLANKS, UTags.Items.PALM_LOGS, 4);
offerPlanksRecipe(exporter, UBlocks.ZAP_PLANKS, UTags.Items.ZAP_LOGS, 4);
offerPlanksRecipe(exporter, UBlocks.WAXED_ZAP_PLANKS, UTags.Items.WAXED_ZAP_LOGS, 4);
offerBarkBlockRecipe(exporter, UBlocks.PALM_WOOD, UBlocks.PALM_LOG);
offerBarkBlockRecipe(exporter, UBlocks.ZAP_WOOD, UBlocks.ZAP_LOG);
offerBarkBlockRecipe(exporter, UBlocks.WAXED_ZAP_WOOD, UBlocks.WAXED_ZAP_LOG);
generateFamily(exporter, UBlockFamilies.PALM);
// zap wood
generateFamily(exporter, UBlockFamilies.ZAP);
offerPlanksRecipe(exporter, UBlocks.ZAP_PLANKS, UTags.Items.ZAP_LOGS, 4);
offerBarkBlockRecipe(exporter, UBlocks.ZAP_WOOD, UBlocks.ZAP_LOG);
// XXX: fixed not being able to craft stripped zap wood and waxed stripped zap wood
offerBarkBlockRecipe(exporter, UBlocks.STRIPPED_ZAP_WOOD, UBlocks.STRIPPED_ZAP_LOG);
// waxed zap wood
offerPlanksRecipe(exporter, UBlocks.WAXED_ZAP_PLANKS, UTags.Items.WAXED_ZAP_LOGS, 4);
offerBarkBlockRecipe(exporter, UBlocks.WAXED_ZAP_WOOD, UBlocks.WAXED_ZAP_LOG);
generateFamily(exporter, UBlockFamilies.WAXED_ZAP);
offerBarkBlockRecipe(exporter, UBlocks.WAXED_STRIPPED_ZAP_WOOD, UBlocks.WAXED_STRIPPED_ZAP_LOG);
offerWaxingRecipes(exporter);
// other doors
offer2x3Recipe(exporter, UBlocks.CRYSTAL_DOOR, UItems.CRYSTAL_SHARD, "door");
offerStableDoorRecipe(exporter, UBlocks.STABLE_DOOR, Either.right(ItemTags.PLANKS), UItems.ROCK_CANDY);
offerStableDoorRecipe(exporter, UBlocks.DARK_OAK_DOOR, Either.right(ItemTags.PLANKS), UItems.ROCK);
}
private static Item getMaterial(Item output, String toStrip, String suffex) {
Identifier id = Registries.ITEM.getId(output).withPath(p -> p.replace(toStrip, "") + suffex);
return Registries.ITEM.getOrEmpty(id)
.or(() -> Registries.ITEM.getOrEmpty(new Identifier(Identifier.DEFAULT_NAMESPACE, id.getPath())))
.orElseThrow(() -> new NoSuchElementException("No item with id " + id));
private void offerChitinBlocksRecipes(Consumer<RecipeJsonProvider> exporter) {
// XXX: Changed chitin recipe to be reversible
offerReversibleCompactingRecipes(exporter, RecipeCategory.BUILDING_BLOCKS, UItems.CARAPACE, RecipeCategory.BUILDING_BLOCKS, UBlocks.CHITIN);
generateFamily(exporter, UBlockFamilies.CHISELED_CHITIN);
offerHiveRecipe(exporter, UBlocks.HIVE, UBlocks.CHITIN, UBlocks.MYSTERIOUS_EGG);
offerHullRecipe(exporter, UBlocks.CHISELLED_CHITIN_HULL, UBlocks.CHISELLED_CHITIN, UBlocks.CHITIN);
// XXX: Changed spikes recipe to give 8 instead of 1
offerSpikesRecipe(exporter, UBlocks.CHITIN_SPIKES, UBlocks.CHITIN);
// TODO: polished chitin
offerPolishedStoneRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CHISELLED_CHITIN, UBlocks.CHITIN);
offerStonecuttingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CHISELLED_CHITIN_HULL, UBlocks.CHISELLED_CHITIN);
offerStonecuttingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CHISELLED_CHITIN_SLAB, UBlocks.CHISELLED_CHITIN, 2);
offerStonecuttingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, UBlocks.CHISELLED_CHITIN_STAIRS, UBlocks.CHISELLED_CHITIN);
}
public static void offerBasketRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input) {
ShapedRecipeJsonBuilder.create(RecipeCategory.TRANSPORTATION, output)
.input(Character.valueOf('#'), input)
private void offerGemstoneAndMagicRecipes(Consumer<RecipeJsonProvider> exporter) {
// XXX: Change diamond to shard recipe to give 6 instead of 3
offerShapelessRecipe(exporter, UItems.CRYSTAL_SHARD, Items.DIAMOND, "crystal_shard", 6);
// XXX: Added recipe to get shards from amethyst shards
offerShapelessRecipe(exporter, UItems.CRYSTAL_SHARD, Items.AMETHYST_SHARD, "crystal_shard", 3);
offer2x2CompactingRecipe(exporter, RecipeCategory.MISC, UItems.GEMSTONE, UItems.CRYSTAL_SHARD);
ShapelessRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.SPELLBOOK)
.input(Items.BOOK).criterion("has_book", conditionsFromItem(Items.BOOK))
.input(UItems.GEMSTONE).criterion("has_gemstone", conditionsFromItem(UItems.GEMSTONE))
.offerTo(exporter);
// magic staff
ShapedRecipeJsonBuilder.create(RecipeCategory.TOOLS, UItems.MAGIC_STAFF)
.input('*', UItems.GEMSTONE).criterion("has_gemstone", conditionsFromItem(UItems.GEMSTONE))
.input('#', UConventionalTags.STICKS).criterion("has_stick", conditionsFromTag(UConventionalTags.STICKS))
.pattern(" *")
.pattern(" # ")
.pattern("# ")
.offerTo(exporter);
// crystal heart
ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, UItems.CRYSTAL_HEART)
.input('#', UItems.CRYSTAL_SHARD).criterion("has_crystal_shard", conditionsFromItem(UItems.CRYSTAL_SHARD))
.pattern("# #")
.pattern("###")
.pattern(" # ")
.offerTo(exporter);
// pegasus amulet
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.GOLDEN_FEATHER)
.input('*', Items.GOLD_NUGGET).criterion("has_nugget", conditionsFromItem(Items.GOLD_NUGGET))
.input('#', UTags.MAGIC_FEATHERS).criterion("has_feather", conditionsFromTag(UTags.MAGIC_FEATHERS))
.pattern("***")
.pattern("*#*")
.pattern("***")
.offerTo(exporter);
offerCompactingRecipe(exporter, RecipeCategory.COMBAT, UItems.GOLDEN_WING, UItems.GOLDEN_FEATHER);
ShapedRecipeJsonBuilder.create(RecipeCategory.TOOLS, UItems.PEGASUS_AMULET)
.input('*', UItems.GOLDEN_WING).criterion("has_wing", conditionsFromItem(UItems.GOLDEN_WING))
.input('#', UItems.GEMSTONE).criterion("has_gemstone", conditionsFromItem(UItems.GEMSTONE))
.pattern("*#*")
.offerTo(exporter);
// unicorn amulet
/*ShapelessRecipeJsonBuilder.create(RecipeCategory.TOOLS, UItems.UNICORN_AMULET)
.input(UItems.PEGASUS_AMULET)
.input(UItems.CRYSTAL_HEART)
.input(UItems.GROGARS_BELL)
.input(Items.TOTEM_OF_UNDYING)
.offerTo(exporter);*/
// friendship bracelet
ShapedRecipeJsonBuilder.create(RecipeCategory.TOOLS, UItems.FRIENDSHIP_BRACELET)
.input('*', Items.STRING)
.input('#', Items.LEATHER).criterion(hasItem(Items.LEATHER), conditionsFromTag(UTags.MAGIC_FEATHERS))
.pattern("*#*")
.pattern("# #")
.pattern("*#*")
.offerTo(exporter);
ComplexRecipeJsonBuilder.create(URecipes.GLOWING_SERIALIZER).offerTo(exporter, "friendship_bracelet_glowing");
// meadowbrook's staff
ShapedRecipeJsonBuilder.create(RecipeCategory.TOOLS, UItems.MEADOWBROOKS_STAFF)
.input('*', UItems.GEMSTONE).criterion(hasItem(UItems.GEMSTONE), conditionsFromItem(UItems.GEMSTONE))
.input('/', UConventionalTags.STICKS).criterion(hasItem(Items.STICK), conditionsFromTag(UConventionalTags.STICKS))
.pattern(" *")
.pattern(" / ")
.pattern("/ ")
.offerTo(exporter);
offerShapelessRecipe(exporter, Items.STICK, UItems.MEADOWBROOKS_STAFF, "stick", 2);
}
private void offerFoodRecipes(Consumer<RecipeJsonProvider> exporter) {
offerShapelessRecipe(exporter, UItems.PINEAPPLE_CROWN, UItems.PINEAPPLE, "seeds", 1);
offerShapelessRecipe(exporter, UItems.SWEET_APPLE_SEEDS, UItems.SWEET_APPLE, "seeds", 3);
offerShapelessRecipe(exporter, UItems.SOUR_APPLE_SEEDS, UItems.SOUR_APPLE, "seeds", 3);
offerShapelessRecipe(exporter, UItems.GREEN_APPLE_SEEDS, UItems.GREEN_APPLE, "seeds", 3);
// XXX: Made golden oak seeds obtainable by crafting
offerShapelessRecipe(exporter, UItems.GOLDEN_OAK_SEEDS, Items.GOLDEN_APPLE, "seeds", 1);
offerPieRecipe(exporter, UItems.APPLE_PIE, UItems.APPLE_PIE_SLICE, Items.WHEAT, UTags.FRESH_APPLES);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.ROCK_STEW)
.input(UItems.ROCK, 3).criterion(hasItem(UItems.ROCK), conditionsFromItem(UItems.ROCK))
.input(Items.BOWL)
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.ROCK_CANDY, 3)
.input(Items.SUGAR, 6).criterion(hasItem(Items.SUGAR), conditionsFromItem(Items.SUGAR))
.input(UItems.PEBBLES, 3)
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.JUICE)
.input(Ingredient.fromTag(UTags.FRESH_APPLES), 6).criterion(hasItem(Items.APPLE), conditionsFromTag(UTags.FRESH_APPLES))
.input(Items.GLASS_BOTTLE)
.group("juice")
.offerTo(exporter);
appendIngredients(ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.MUFFIN), Items.SUGAR, Items.EGG, Items.POTATO, UItems.JUICE, UItems.WHEAT_WORMS).offerTo(exporter);
// XXX: Removed the complex cider recipe
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.MUG)
.input('*', Items.IRON_NUGGET).criterion(hasItem(Items.IRON_NUGGET), conditionsFromItem(Items.IRON_NUGGET))
.input('#', UConventionalTags.STICKS).criterion(hasItem(Items.STICK), conditionsFromTag(UConventionalTags.STICKS))
.pattern("# #")
.pattern("* *")
.pattern(" # ")
.offerTo(exporter);
// XXX: Changed the simple cider recipe to require apples
appendIngredients(ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.CIDER), UItems.BURNED_JUICE, UItems.MUG)
.input(Ingredient.fromTag(UTags.FRESH_APPLES)).criterion(hasItem(Items.APPLE), conditionsFromTag(UTags.FRESH_APPLES))
.offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.HAY_FRIES)
.input('#', UItems.OATS).criterion(hasItem(UItems.OATS), conditionsFromItem(UItems.OATS))
.pattern("###")
.offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.HAY_BURGER)
.input('~', Items.BREAD).criterion(hasItem(Items.BREAD), conditionsFromItem(Items.BREAD))
.input('#', UItems.OATS).criterion(hasItem(UItems.OATS), conditionsFromItem(UItems.OATS))
.pattern(" # ")
.pattern("~~~")
.pattern(" # ")
.offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.DAFFODIL_DAISY_SANDWICH)
.input('#', Items.BREAD).criterion(hasItem(Items.BREAD), conditionsFromItem(Items.BREAD))
.input('~', ItemTags.SMALL_FLOWERS).criterion("has_flower", conditionsFromTag(ItemTags.SMALL_FLOWERS))
.pattern(" # ")
.pattern("~~~")
.pattern(" # ")
.offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.HORSE_SHOE_FRIES, 15)
.input('#', Items.BAKED_POTATO).criterion(hasItem(Items.BAKED_POTATO), conditionsFromItem(Items.BAKED_POTATO))
.pattern("# #")
.pattern("# #")
.pattern(" # ")
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.OATMEAL)
.input(UItems.OATS, 3).criterion(hasItem(UItems.OATS), conditionsFromItem(UItems.OATS))
.input(ConventionalItemTags.MILK_BUCKETS)
.input(Items.BOWL)
.offerTo(exporter);
offerSmelting(exporter, List.of(UItems.JUICE), RecipeCategory.FOOD, UItems.BURNED_JUICE, 0, 100, "juice");
offerSmelting(exporter, List.of(Items.BREAD), RecipeCategory.FOOD, UItems.TOAST, 0.2F, 430, "bread");
offerSmelting(exporter, List.of(UItems.TOAST), RecipeCategory.FOOD, UItems.BURNED_TOAST, 0.2F, 30, "bread");
offerSmelting(exporter, List.of(UItems.BURNED_JUICE, UItems.BURNED_TOAST), RecipeCategory.FOOD, Items.CHARCOAL, 1, 20, "coal");
offerSmelting(exporter, List.of(UItems.HAY_FRIES), RecipeCategory.FOOD, UItems.CRISPY_HAY_FRIES, 1F, 25, "hay_fries");
// XXX: Increased experience from cooking zap apples
offerSmelting(exporter, List.of(UItems.ZAP_APPLE), RecipeCategory.FOOD, UItems.COOKED_ZAP_APPLE, 1.2F, 430, "zap_apple");
// XXX: Make zap apple jam jar recipe shapeless
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.ZAP_APPLE_JAM_JAR)
.input(UItems.COOKED_ZAP_APPLE, 6).criterion(hasItem(UItems.COOKED_ZAP_APPLE), conditionsFromItem(UItems.COOKED_ZAP_APPLE))
.input(UItems.EMPTY_JAR)
.offerTo(exporter);
// XXX: Make jam toast recipe shapeless
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.JAM_TOAST, 8)
.input(UItems.ZAP_APPLE_JAM_JAR).criterion(hasItem(UItems.ZAP_APPLE_JAM_JAR), conditionsFromItem(UItems.ZAP_APPLE_JAM_JAR))
.input(UItems.TOAST, 8)
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, UItems.CANDIED_APPLE)
.input(UConventionalTags.STICKS)
.input(UTags.FRESH_APPLES).criterion(hasItem(UItems.ZAP_APPLE_JAM_JAR), conditionsFromItem(UItems.ZAP_APPLE_JAM_JAR))
.input(Items.SUGAR, 4)
.offerTo(exporter);
}
private void offerSeaponyRecipes(Consumer<RecipeJsonProvider> exporter) {
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.SHELLY)
.input('C', UItems.CLAM_SHELL).criterion("has_clam_shell", conditionsFromItem(UItems.CLAM_SHELL))
.input('o', UItems.ROCK_CANDY)
.pattern("o o")
.pattern(" C ")
.offerTo(exporter);
ShapedRecipeJsonBuilder.create(RecipeCategory.COMBAT, UItems.PEARL_NECKLACE)
.input('#', UTags.SHELLS).criterion("has_shell", conditionsFromTag(UTags.SHELLS))
.input('~', Items.STRING)
.pattern("# #")
.pattern("# #")
.pattern("~#~")
.offerTo(exporter);
}
private void offerEarthPonyRecipes(Consumer<RecipeJsonProvider> exporter) {
Arrays.stream(ItemFamilies.BASKETS).forEach(basket -> offerBasketRecipe(exporter, basket, CraftingMaterialHelper.getMaterial(basket, "_basket", "_planks")));
Arrays.stream(ItemFamilies.HORSE_SHOES).forEach(horseshoe -> offerHorseshoeRecipe(exporter, horseshoe, CraftingMaterialHelper.getMaterial(horseshoe, "_horse_shoe", "_ingot")));
Arrays.stream(ItemFamilies.POLEARMS).forEach(polearm -> {
if (polearm == UItems.NETHERITE_POLEARM) {
offerNetheriteUpgradeRecipe(exporter, UItems.DIAMOND_POLEARM, RecipeCategory.TOOLS, UItems.NETHERITE_POLEARM);
} else {
offerPolearmRecipe(exporter, polearm, CraftingMaterialHelper.getMaterial(polearm, "_polearm", "_ingot"));
}
});
// weather vane
offerWeatherVaneRecipe(exporter, UBlocks.WEATHER_VANE, Items.IRON_NUGGET);
// Giant balloons
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, UItems.GIANT_BALLOON)
.input('-', ItemTags.WOOL_CARPETS).criterion("has_carpet", conditionsFromTag(ItemTags.WOOL_CARPETS))
.input('#', ItemTags.WOOL).criterion("has_wool", conditionsFromTag(ItemTags.WOOL))
.pattern("---")
.pattern("# #")
.pattern("---")
.offerTo(exporter);
// utility
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, Items.DIRT)
.input('*', UItems.WHEAT_WORMS).criterion("has_wheat_worms", conditionsFromItem(UItems.WHEAT_WORMS))
.input('#', ItemTags.SAND).criterion("has_sand", conditionsFromTag(ItemTags.SAND))
.pattern("*#")
.pattern("#*")
.offerTo(exporter, convertBetween(Items.DIRT, UItems.WHEAT_WORMS));
offer2x2CompactingRecipe(exporter, RecipeCategory.BUILDING_BLOCKS, Items.COBBLESTONE, UItems.ROCK);
// XXX: Made gravel <-> pebbles conversion reversable
offerReversibleCompactingRecipesWithReverseRecipeGroup(exporter, RecipeCategory.MISC, UItems.PEBBLES, RecipeCategory.BUILDING_BLOCKS, Blocks.GRAVEL, convertBetween(UItems.PEBBLES, Blocks.GRAVEL), "pebbles");
// XXX: Added sus gravel -> pebbles recipe
offerShapelessRecipe(exporter, UItems.PEBBLES, Blocks.SUSPICIOUS_GRAVEL, "pebbles", 9);
offerSmelting(exporter, List.of(UItems.GOLDEN_OAK_SEEDS, UItems.GOLDEN_FEATHER), RecipeCategory.MISC, Items.GOLD_NUGGET, 3F, 10, "gold_nugget");
}
private static ShapelessRecipeJsonBuilder appendIngredients(ShapelessRecipeJsonBuilder builder, ItemConvertible...ingredients) {
for (ItemConvertible ingredient : ingredients) {
builder.input(ingredient).criterion(hasItem(ingredient), conditionsFromItem(ingredient));
}
return builder;
}
public static void offerShapelessRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, TagKey<Item> input, @Nullable String group, int outputCount) {
ShapelessRecipeJsonBuilder.create(RecipeCategory.MISC, output, outputCount)
.input(input).criterion(CraftingMaterialHelper.hasTag(input), conditionsFromTag(input))
.group(group)
.offerTo(exporter, getItemPath(output) + "_from_" + input.id().getPath());
}
public static void offerPieRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible pie, ItemConvertible slice, ItemConvertible crust, TagKey<Item> filling) {
ShapedRecipeJsonBuilder.create(RecipeCategory.FOOD, pie)
.input('*', crust).criterion("has_crust", conditionsFromItem(crust))
.input('#', filling).criterion("has_filling", conditionsFromTag(filling))
.pattern("***")
.pattern("###")
.pattern("***")
.offerTo(exporter);
ShapelessRecipeJsonBuilder.create(RecipeCategory.FOOD, pie)
.input(slice, 4)
.criterion(hasItem(slice), conditionsFromItem(slice))
.offerTo(exporter, getItemPath(pie) + "_from_" + getItemPath(slice));
}
public static void offerBasketRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, Either<ItemConvertible, TagKey<Item>> input) {
CraftingMaterialHelper.input(ShapedRecipeJsonBuilder.create(RecipeCategory.TRANSPORTATION, output), '#', input)
.criterion(CraftingMaterialHelper.hasEither(input), CraftingMaterialHelper.conditionsFromEither(input))
.pattern("# #")
.pattern("# #")
.pattern("###")
.group("basket")
.criterion(VanillaRecipeProvider.hasItem(input), VanillaRecipeProvider.conditionsFromItem(input))
.offerTo(exporter);
}
public static void offerHorseshoeRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, Either<ItemConvertible, TagKey<Item>> input) {
CraftingMaterialHelper
.input(ShapedRecipeJsonBuilder.create(RecipeCategory.COMBAT, output), '#', input)
.criterion(CraftingMaterialHelper.hasEither(input), CraftingMaterialHelper.conditionsFromEither(input))
.pattern("# #")
.pattern("# #")
.pattern(" # ")
.group("horseshoe")
.offerTo(exporter);
}
public static void offerHiveRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible chitin, ItemConvertible egg) {
ShapedRecipeJsonBuilder.create(RecipeCategory.MISC, output)
.input('#', chitin)
.input('o', egg).criterion(hasItem(egg), conditionsFromItem(egg))
.pattern(" # ")
.pattern("#o#")
.pattern(" # ")
.group("chitin")
.offerTo(exporter);
}
public static void offerPolearmRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, Either<ItemConvertible, TagKey<Item>> input) {
CraftingMaterialHelper
.input(ShapedRecipeJsonBuilder.create(RecipeCategory.TOOLS, output), 'o', input).criterion(CraftingMaterialHelper.hasEither(input), CraftingMaterialHelper.conditionsFromEither(input))
.input('#', UConventionalTags.STICKS)
.pattern(" o")
.pattern(" # ")
.pattern("# ")
.group("polearm")
.offerTo(exporter);
}
public static void offerHullRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible outside, ItemConvertible inside) {
ShapedRecipeJsonBuilder.create(RecipeCategory.BUILDING_BLOCKS, output, 4)
.input('#', outside).criterion(hasItem(outside), conditionsFromItem(outside))
.input('o', inside).criterion(hasItem(inside), conditionsFromItem(inside))
.pattern("##")
.pattern("oo")
.group("hull")
.offerTo(exporter);
}
public static void offerSpikesRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input) {
ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output, 8)
.input('#', input).criterion(hasItem(input), conditionsFromItem(input))
.pattern(" # ")
.pattern("###")
.group("spikes")
.offerTo(exporter);
}
public static void offerChestRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input) {
ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output)
.input('#', input)
.pattern("###")
.pattern("# #")
.pattern("###")
.criterion("has_lots_of_items", new InventoryChangedCriterion.Conditions(LootContextPredicate.EMPTY, NumberRange.IntRange.atLeast(10), NumberRange.IntRange.ANY, NumberRange.IntRange.ANY, new ItemPredicate[0]))
.offerTo(exporter);
}
public static void offer2x3Recipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input, String group) {
createDoorRecipe(output, Ingredient.ofItems(input))
.criterion(hasItem(input), conditionsFromItem(input))
.group(group)
.offerTo(exporter);
}
public static void offerStableDoorRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, Either<ItemConvertible, TagKey<Item>> body, ItemConvertible trim) {
CraftingMaterialHelper
.input(ShapedRecipeJsonBuilder.create(RecipeCategory.REDSTONE, output, 3), '#', body).criterion(CraftingMaterialHelper.hasEither(body), CraftingMaterialHelper.conditionsFromEither(body))
.input('*', trim).criterion(hasItem(trim), conditionsFromItem(trim))
.pattern("*#*")
.pattern("*#*")
.pattern("*#*")
.group("stable_door")
.offerTo(exporter);
}
public static void offerWeatherVaneRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input) {
ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output)
.input('*', input).criterion(hasItem(input), conditionsFromItem(input))
.pattern(" **")
.pattern("** ")
.pattern(" * ")
.offerTo(exporter);
}
public static ShapedRecipeJsonBuilder createCustomBedRecipe(ItemConvertible output, Either<ItemConvertible, TagKey<Item>> input, Either<ItemConvertible, TagKey<Item>> planks) {
var builder = ShapedRecipeJsonBuilder.create(RecipeCategory.DECORATIONS, output);
CraftingMaterialHelper.input(builder, '#', input).criterion(CraftingMaterialHelper.hasEither(input), CraftingMaterialHelper.conditionsFromEither(input));
return CraftingMaterialHelper.input(builder, 'X', planks)
.pattern("###")
.pattern("XXX")
.group("bed");
}
private void offerBedSheetRecipes(Consumer<RecipeJsonProvider> exporter) {
PatternTemplate.ONE_COLOR.offerWithoutConversion(exporter, UItems.KELP_BED_SHEETS, Items.KELP);
// XXX: Added white bed sheets, and added a recipe to dye white bed sheets any color
// XXX: Added recipes to change any bedsheet into any solid color using the right wool
WOOLS.forEach(wool -> PatternTemplate.ONE_COLOR.offerTo(exporter, CraftingMaterialHelper.getItem(Unicopia.id(Registries.ITEM.getId(wool).getPath().replace("_wool", "_bed_sheets"))), wool));
PatternTemplate.TWO_COLOR.offerTo(exporter, UItems.APPLE_BED_SHEETS, Items.GREEN_WOOL, Items.LIME_WOOL);
PatternTemplate.TWO_COLOR.offerTo(exporter, UItems.BARRED_BED_SHEETS, Items.LIGHT_BLUE_WOOL, Items.WHITE_WOOL);
PatternTemplate.TWO_COLOR.offerTo(exporter, UItems.CHECKERED_BED_SHEETS, Items.GREEN_WOOL, Items.BROWN_WOOL);
PatternTemplate.THREE_COLOR.offerTo(exporter, UItems.RAINBOW_PWR_BED_SHEETS, Items.WHITE_WOOL, Items.PINK_WOOL, Items.RED_WOOL);
PatternTemplate.THREE_COLOR.offerTo(exporter, UItems.RAINBOW_BPY_BED_SHEETS, Items.PINK_WOOL, Items.YELLOW_WOOL, Items.LIGHT_BLUE_WOOL);
PatternTemplate.THREE_COLOR.offerTo(exporter, UItems.RAINBOW_BPW_BED_SHEETS, Items.PINK_WOOL, Items.LIGHT_BLUE_WOOL, Items.WHITE_WOOL);
PatternTemplate.FOUR_COLOR.offerTo(exporter, UItems.RAINBOW_PBG_BED_SHEETS, Items.PURPLE_WOOL, Items.WHITE_WOOL, Items.LIGHT_GRAY_WOOL, Items.BLACK_WOOL);
PatternTemplate.SEVEN_COLOR.offerTo(exporter, UItems.RAINBOW_BED_SHEETS, UItems.RAINBOW_BED_SHEETS, Items.LIGHT_BLUE_WOOL, Items.RED_WOOL, Items.ORANGE_WOOL, Items.YELLOW_WOOL, Items.BLUE_WOOL, Items.GREEN_WOOL, Items.PURPLE_WOOL);
}
public static void offerCompactingRecipe(Consumer<RecipeJsonProvider> exporter, RecipeCategory category, ItemConvertible output, ItemConvertible input, int resultCount) {
offerCompactingRecipe(exporter, category, output, input, hasItem(input), resultCount);
}
public static void offerCompactingRecipe(Consumer<RecipeJsonProvider> exporter, RecipeCategory category, ItemConvertible output, ItemConvertible input, String criterionName, int resultCount) {
ShapelessRecipeJsonBuilder.create(category, output, resultCount)
.input(input, 9).criterion(criterionName, conditionsFromItem(input))
.offerTo(exporter);
}
@ -76,14 +552,17 @@ public class URecipeProvider extends FabricRecipeProvider {
offerWaxingRecipe(exporter, output, input);
});
offerWaxingRecipe(exporter, UBlocks.WAXED_ZAP_PLANKS, UBlocks.ZAP_PLANKS);
offerWaxingRecipe(exporter, UBlocks.WAXED_ZAP_LOG, UBlocks.ZAP_LOG);
offerWaxingRecipe(exporter, UBlocks.WAXED_ZAP_WOOD, UBlocks.ZAP_WOOD);
offerWaxingRecipe(exporter, UBlocks.WAXED_STRIPPED_ZAP_LOG, UBlocks.STRIPPED_ZAP_LOG);
offerWaxingRecipe(exporter, UBlocks.WAXED_STRIPPED_ZAP_WOOD, UBlocks.STRIPPED_ZAP_WOOD);
}
public static void offerWaxingRecipe(Consumer<RecipeJsonProvider> exporter, ItemConvertible output, ItemConvertible input) {
ShapelessRecipeJsonBuilder.create(RecipeCategory.BUILDING_BLOCKS, output)
.input(input)
.input(Items.HONEYCOMB).group(RecipeProvider.getItemPath(output))
.criterion(RecipeProvider.hasItem(input), RecipeProvider.conditionsFromItem(input))
.offerTo(exporter, RecipeProvider.convertBetween(output, Items.HONEYCOMB));
.input(Items.HONEYCOMB)
.input(input).criterion(hasItem(input), conditionsFromItem(input))
.group(getItemPath(output))
.offerTo(exporter, convertBetween(output, Items.HONEYCOMB));
}
}

1
src/main/java/com/minelittlepony/unicopia/item/UItems.java
View file

@ -166,6 +166,7 @@ public interface UItems {
Item GIANT_BALLOON = register("giant_balloon", new HotAirBalloonItem(new Item.Settings().maxCount(1)), ItemGroups.TOOLS);
Item SPECTRAL_CLOCK = register("spectral_clock", new Item(new Item.Settings()), ItemGroups.TOOLS);
Item WHITE_BED_SHEETS = register(CloudBedBlock.SheetPattern.WHITE);
Item LIGHT_GRAY_BED_SHEETS = register(CloudBedBlock.SheetPattern.LIGHT_GRAY);
Item GRAY_BED_SHEETS = register(CloudBedBlock.SheetPattern.GRAY);
Item BLACK_BED_SHEETS = register(CloudBedBlock.SheetPattern.BLACK);

30
src/main/resources/data/unicopia/advancements/recipes/blocks/chiselled_chitin.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:chiselled_chitin"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:chitin" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:chiselled_chitin"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/chiselled_chitin_hull.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:chiselled_chitin_hull"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:chiselled_chitin" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:chiselled_chitin_hull"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/chiselled_chitin_slab.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:chiselled_chitin_slab"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:chiselled_chitin" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:chiselled_chitin_slab"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/chiselled_chitin_stairs.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:chiselled_chitin_stairs"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:chiselled_chitin" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:chiselled_chitin_stairs"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/chitin_spikes.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:chitin_spikes"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:chitin" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:chitin_spikes"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_brick_slab.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_brick_slab"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud_bricks" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_brick_slab"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_brick_stairs.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_brick_stairs"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud_bricks" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_brick_stairs"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_pillar.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_pillar"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_pillar"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_plank_slab.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_plank_slab"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud_planks" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_plank_slab"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_plank_stairs.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_plank_stairs"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud_planks" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_plank_stairs"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_planks.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_planks"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_planks"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_slab.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_slab"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_slab"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/cloud_stairs.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_stairs"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_stairs"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/dense_cloud.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:dense_cloud"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:dense_cloud"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/dense_cloud_slab.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:dense_cloud_slab"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:dense_cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:dense_cloud_slab"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/blocks/dense_cloud_stairs.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:dense_cloud_stairs"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:dense_cloud" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:dense_cloud_stairs"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/cloud_lump.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cloud_lump"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:cloud_jars" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cloud_lump"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/crystal_heart.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:crystal_heart"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:crystal_shard" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:crystal_heart"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/empty_jar.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:empty_jar"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:glass" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:empty_jar"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/apple_pie.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:apple_pie"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:fresh_apples" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:apple_pie"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/apple_pie_from_slices.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:apple_pie_slice_to_apple_pie"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:apple_pie_slice" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:apple_pie_slice_to_apple_pie"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/burned_juice.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:burned_juice"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:juice" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:burned_juice"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/burned_toast.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:burned_toast"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:toast" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:burned_toast"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

32
src/main/resources/data/unicopia/advancements/recipes/food/candied_apple.json
View file

@ -1,32 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:candied_apple"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:stick" ] },
{ "items": [ "minecraft:sugar" ] },
{ "tag": "unicopia:fresh_apples" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:candied_apple"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

34
src/main/resources/data/unicopia/advancements/recipes/food/cider.json
View file

@ -1,34 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:cider",
"unicopia:easy_cider"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:burned_juice" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:cider"
}
},
"has_the_easy_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:easy_cider"
}
}
},
"requirements": [
[ "has_ingredients", "has_the_recipe", "has_the_easy_recipe" ]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/hay_fries.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:hay_fries"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "unicopia:oats" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:hay_fries"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/horse_shoe_fries.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:horse_shoe_fries"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:baked_potato" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:horse_shoe_fries"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

31
src/main/resources/data/unicopia/advancements/recipes/food/jam_toast.json
View file

@ -1,31 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:jam_toast"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:toast" ] },
{ "items": [ "unicopia:zap_apple_jam_jar" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:jam_toast"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/juice.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:juice"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:fresh_apples" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:juice"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

38
src/main/resources/data/unicopia/advancements/recipes/food/muffin.json
View file

@ -1,38 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:muffin"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{
"items": [
"minecraft:sugar",
"minecraft:egg",
"minecraft:potato",
"unicopia:juice",
"unicopia:wheat_worms"
]
}
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:muffin"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/oatmeal.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:oatmeal"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:oats" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:oatmeal"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

31
src/main/resources/data/unicopia/advancements/recipes/food/rock_candy.json
View file

@ -1,31 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:rock_candy"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:pebbles" ] },
{ "items": [ "minecraft:sugar" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:rock_candy"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/rock_stew.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:rock_stew"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:rock" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:rock_stew"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/toast.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:toast"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:bread" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:toast"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/food/zap_apple_jam_jar.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:zap_apple_jam_jar"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:empty_jar" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:zap_apple_jam_jar"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/friendship_bracelet.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:friendship_bracelet"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:leather", "minecraft:string" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:friendship_bracelet"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/gemstone.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:gemstone"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:crystal_shard" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:gemstone"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

31
src/main/resources/data/unicopia/advancements/recipes/golden_feather.json
View file

@ -1,31 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:golden_feather",
"unicopia:pegasus_amulet"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "unicopia:magic_feathers" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:golden_feather"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/golden_wing.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:golden_wing"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:golden_feather" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:golden_wing"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/meadowbrooks_staff.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:meadowbrooks_staff"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "item": "minecraft:stick" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:meadowbrooks_staff"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/mug.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:mug"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:stick" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:mug"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/pegasus_amulet.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:pegasus_amulet"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:golden_wing" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:pegasus_amulet"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/pineapple_crown.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:pineapple_crown"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:pineapple" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:pineapple_crown"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/shelly.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:shelly"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:clam_shell", "unicopia:rock_candy" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:shelly"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/spellbook.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:spellbook"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:gemstone", "unicopia:botched_gem" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:spellbook"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/diamond_polearm.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:diamond_polearm"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:diamond" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:diamond_polearm"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/golden_polearm.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:golden_polearm"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:gold_ingot" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:golden_polearm"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/iron_polearm.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:iron_polearm"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:iron_ingot" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:iron_polearm"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/netherite_polearm_smithing.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:netherite_polearm_smithing"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:netherite_ingot" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:netherite_polearm_smithing"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/stone_polearm.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:stone_polearm"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "tag": "minecraft:stone_tool_materials" }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:stone_polearm"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/tools/wooden_polearm.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:wooden_polearm"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:stick" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:wooden_polearm"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/unicorn_amulet.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:unicorn_amulet"
]
},
"criteria": {
"has_ingredients": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "unicopia:broken_alicorn_amulet" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:broken_alicorn_amulet"
}
}
},
"requirements": [
[
"has_ingredients",
"has_the_recipe"
]
]
}

30
src/main/resources/data/unicopia/advancements/recipes/weather_vane.json
View file

@ -1,30 +0,0 @@
{
"parent": "minecraft:recipes/root",
"rewards": {
"recipes": [
"unicopia:weather_vane"
]
},
"criteria": {
"has_iron": {
"trigger": "minecraft:inventory_changed",
"conditions": {
"items": [
{ "items": [ "minecraft:iron_nugget", "minecraft:iron_ingot" ] }
]
}
},
"has_the_recipe": {
"trigger": "minecraft:recipe_unlocked",
"conditions": {
"recipe": "unicopia:weather_vane"
}
}
},
"requirements": [
[
"has_iron",
"has_the_recipe"
]
]
}

19
src/main/resources/data/unicopia/recipes/apple_pie.json
View file

@ -1,19 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"***",
"###",
"***"
],
"key": {
"#": {
"tag": "unicopia:fresh_apples"
},
"*": {
"item": "minecraft:wheat"
}
},
"result": {
"item": "unicopia:apple_pie"
}
}

12
src/main/resources/data/unicopia/recipes/apple_pie_slice_to_apple_pie.json
View file

@ -1,12 +0,0 @@
{
"type": "minecraft:crafting_shapeless",
"ingredients": [
{ "item": "unicopia:apple_pie_slice" },
{ "item": "unicopia:apple_pie_slice" },
{ "item": "unicopia:apple_pie_slice" },
{ "item": "unicopia:apple_pie_slice" }
],
"result": {
"item": "unicopia:apple_pie"
}
}

23
src/main/resources/data/unicopia/recipes/arrow.json
View file

@ -1,23 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"X",
"#",
"Y"
],
"key": {
"#": {
"item": "minecraft:stick"
},
"X": {
"item": "minecraft:flint"
},
"Y": {
"tag": "unicopia:magic_feathers"
}
},
"result": {
"item": "minecraft:arrow",
"count": 4
}
}

21
src/main/resources/data/unicopia/recipes/bed_sheets/apple.json
View file

@ -1,21 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"#%#",
"% %",
" %#"
],
"key": {
"#": {
"item": "minecraft:green_wool"
},
"%": {
"item": "minecraft:lime_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:apple_bed_sheets"
}
}

21
src/main/resources/data/unicopia/recipes/bed_sheets/bar.json
View file

@ -1,21 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"#%#",
"% %",
" %#"
],
"key": {
"#": {
"item": "minecraft:light_blue_wool"
},
"%": {
"item": "minecraft:white_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:barred_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/black.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:black_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:black_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/blue.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:blue_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:blue_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/brown.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:brown_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:brown_bed_sheets"
}
}

21
src/main/resources/data/unicopia/recipes/bed_sheets/checker.json
View file

@ -1,21 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"#%#",
"% %",
" %#"
],
"key": {
"#": {
"item": "minecraft:green_wool"
},
"%": {
"item": "minecraft:brown_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:checkered_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/cyan.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:cyan_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:cyan_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/gray.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:gray_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:gray_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/green.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:green_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:green_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/kelp.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:kelp"
}
},
"result": {
"count": 1,
"item": "unicopia:kelp_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/light_blue.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:light_blue_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:light_blue_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/light_gray.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:light_gray_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:light_gray_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/lime.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:lime_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:lime_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/magenta.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:magenta_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:magenta_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/orange.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:orange_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:orange_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/pink.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:pink_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:pink_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/purple.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:purple_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:purple_bed_sheets"
}
}

36
src/main/resources/data/unicopia/recipes/bed_sheets/rainbow.json
View file

@ -1,36 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"ROY",
"L B",
" PG"
],
"key": {
"Y": {
"item": "minecraft:yellow_wool"
},
"O": {
"item": "minecraft:orange_wool"
},
"R": {
"item": "minecraft:red_wool"
},
"G": {
"item": "minecraft:green_wool"
},
"B": {
"item": "minecraft:blue_wool"
},
"P": {
"item": "minecraft:purple_wool"
},
"L": {
"item": "minecraft:light_blue_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:rainbow_bed_sheets"
}
}

24
src/main/resources/data/unicopia/recipes/bed_sheets/rainbow_bpw.json
View file

@ -1,24 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"PWP",
"B B",
" WP"
],
"key": {
"B": {
"item": "minecraft:light_blue_wool"
},
"P": {
"item": "minecraft:pink_wool"
},
"W": {
"item": "minecraft:white_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:rainbow_bpw_bed_sheets"
}
}

24
src/main/resources/data/unicopia/recipes/bed_sheets/rainbow_bpy.json
View file

@ -1,24 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"PBP",
"Y Y",
" BP"
],
"key": {
"P": {
"item": "minecraft:pink_wool"
},
"B": {
"item": "minecraft:light_blue_wool"
},
"Y": {
"item": "minecraft:yellow_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:rainbow_bpy_bed_sheets"
}
}

27
src/main/resources/data/unicopia/recipes/bed_sheets/rainbow_pgb.json
View file

@ -1,27 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"WGB",
"P G",
" PW"
],
"key": {
"P": {
"item": "minecraft:purple_wool"
},
"W": {
"item": "minecraft:white_wool"
},
"G": {
"item": "minecraft:light_gray_wool"
},
"B": {
"item": "minecraft:black_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:rainbow_pbg_bed_sheets"
}
}

24
src/main/resources/data/unicopia/recipes/bed_sheets/rainbow_pwr.json
View file

@ -1,24 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"WRW",
"P P",
" RW"
],
"key": {
"P": {
"item": "minecraft:pink_wool"
},
"W": {
"item": "minecraft:white_wool"
},
"R": {
"item": "minecraft:red_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:rainbow_pwr_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/red.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:red_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:red_bed_sheets"
}
}

18
src/main/resources/data/unicopia/recipes/bed_sheets/yellow.json
View file

@ -1,18 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"group": "bed_sheets",
"pattern": [
"###",
"# #",
" ##"
],
"key": {
"#": {
"item": "minecraft:yellow_wool"
}
},
"result": {
"count": 1,
"item": "unicopia:yellow_bed_sheets"
}
}

9
src/main/resources/data/unicopia/recipes/burned_juice.json
View file

@ -1,9 +0,0 @@
{
"type": "smelting",
"ingredient": {
"item": "unicopia:juice"
},
"result": "unicopia:burned_juice",
"experience": 0,
"cookingtime": 100
}

9
src/main/resources/data/unicopia/recipes/burned_juice_to_coal.json
View file

@ -1,9 +0,0 @@
{
"type": "smelting",
"ingredient": {
"item": "unicopia:burned_juice"
},
"result": "minecraft:coal",
"experience": 1,
"cookingtime": 20
}

9
src/main/resources/data/unicopia/recipes/burned_toast.json
View file

@ -1,9 +0,0 @@
{
"type": "smelting",
"ingredient": {
"item": "unicopia:toast"
},
"result": "unicopia:burned_toast",
"experience": 0.2,
"cookingtime": 30
}

12
src/main/resources/data/unicopia/recipes/candied_apple.json
View file

@ -1,12 +0,0 @@
{
"type": "minecraft:crafting_shapeless",
"ingredients": [
{ "item": "minecraft:stick" },
{ "tag": "unicopia:fresh_apples" },
{ "item": "minecraft:sugar" },
{ "item": "minecraft:sugar" },
{ "item": "minecraft:sugar" },
{ "item": "minecraft:sugar" }
],
"result": { "item": "unicopia:candied_apple" }
}

13
src/main/resources/data/unicopia/recipes/chiselled_chitin.json
View file

@ -1,13 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"##",
"##"
],
"key": {
"#": [
{ "item": "unicopia:chitin" }
]
},
"result": { "item": "unicopia:chiselled_chitin", "count": 4 }
}

16
src/main/resources/data/unicopia/recipes/chiselled_chitin_hull.json
View file

@ -1,16 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"##",
"%%"
],
"key": {
"#": [
{ "item": "unicopia:chiselled_chitin" }
],
"%": [
{ "item": "unicopia:chitin" }
]
},
"result": { "item": "unicopia:chiselled_chitin_hull", "count": 4 }
}

12
src/main/resources/data/unicopia/recipes/chiselled_chitin_slab.json
View file

@ -1,12 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"###"
],
"key": {
"#": [
{ "item": "unicopia:chiselled_chitin" }
]
},
"result": { "item": "unicopia:chiselled_chitin_slab", "count": 6 }
}

14
src/main/resources/data/unicopia/recipes/chiselled_chitin_stairs.json
View file

@ -1,14 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"# ",
"## ",
"###"
],
"key": {
"#": [
{ "item": "unicopia:chiselled_chitin" }
]
},
"result": { "item": "unicopia:chiselled_chitin_stairs", "count": 4 }
}

14
src/main/resources/data/unicopia/recipes/chitin.json
View file

@ -1,14 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
"###",
"###",
"###"
],
"key": {
"#": [
{ "item": "unicopia:carapace" }
]
},
"result": { "item": "unicopia:chitin", "count": 1 }
}

13
src/main/resources/data/unicopia/recipes/chitin_spikes.json
View file

@ -1,13 +0,0 @@
{
"type": "minecraft:crafting_shaped",
"pattern": [
" # ",
"###"
],
"key": {
"#": [
{ "item": "unicopia:chitin" }
]
},
"result": { "item": "unicopia:chitin_spikes", "count": 1 }
}

Some files were not shown because too many files have changed in this diff Show more