2021-10-24 18:49:48 +02:00
|
|
|
package de.ellpeck.actuallyadditions.mod.crafting;
|
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
import com.mojang.serialization.Codec;
|
|
|
|
import com.mojang.serialization.DataResult;
|
|
|
|
import com.mojang.serialization.codecs.RecordCodecBuilder;
|
|
|
|
import net.minecraft.core.NonNullList;
|
2024-03-03 01:20:53 +01:00
|
|
|
import net.minecraft.core.RegistryAccess;
|
2024-03-02 21:23:08 +01:00
|
|
|
import net.minecraft.network.FriendlyByteBuf;
|
|
|
|
import net.minecraft.world.Container;
|
|
|
|
import net.minecraft.world.item.ItemStack;
|
|
|
|
import net.minecraft.world.item.crafting.Ingredient;
|
|
|
|
import net.minecraft.world.item.crafting.Recipe;
|
|
|
|
import net.minecraft.world.item.crafting.RecipeSerializer;
|
|
|
|
import net.minecraft.world.item.crafting.RecipeType;
|
|
|
|
import net.minecraft.world.level.Level;
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2021-11-13 17:30:53 +01:00
|
|
|
import javax.annotation.Nonnull;
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2024-03-02 21:23:08 +01:00
|
|
|
public class CrushingRecipe implements Recipe<Container> {
|
2021-10-24 18:49:48 +02:00
|
|
|
public static String NAME = "crushing";
|
|
|
|
protected Ingredient input;
|
2024-03-04 20:21:48 +01:00
|
|
|
protected NonNullList<CrushingResult> outputs;
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
public CrushingRecipe(Ingredient input, NonNullList<CrushingResult> outputList) {
|
2021-10-24 18:49:48 +02:00
|
|
|
this.input = input;
|
2024-03-04 20:21:48 +01:00
|
|
|
this.outputs = outputList;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
2021-11-13 17:30:53 +01:00
|
|
|
public CrushingRecipe(Ingredient input, ItemStack outputOne, float chance1, ItemStack outputTwo, float chance2) {
|
2024-03-04 20:21:48 +01:00
|
|
|
this(input, createList(new CrushingResult(outputOne, chance1), new CrushingResult(outputTwo, chance2)));
|
|
|
|
}
|
|
|
|
|
|
|
|
private static NonNullList<CrushingResult> createList(CrushingResult... results) {
|
|
|
|
NonNullList<CrushingResult> list = NonNullList.create();
|
|
|
|
for (CrushingResult result : results) {
|
|
|
|
list.add(result);
|
|
|
|
}
|
|
|
|
return list;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2024-03-02 21:23:08 +01:00
|
|
|
public boolean matches(Container pInv, Level pLevel) {
|
2021-10-24 18:49:48 +02:00
|
|
|
return input.test(pInv.getItem(0));
|
|
|
|
}
|
|
|
|
|
2021-12-30 18:30:01 +01:00
|
|
|
public boolean matches (ItemStack stack) {
|
|
|
|
return input.test(stack);
|
|
|
|
}
|
|
|
|
|
2023-01-15 22:46:42 +01:00
|
|
|
@Override
|
|
|
|
public boolean isSpecial() {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-10-24 18:49:48 +02:00
|
|
|
@Override
|
2021-11-13 17:30:53 +01:00
|
|
|
@Nonnull
|
2024-03-03 01:20:53 +01:00
|
|
|
public ItemStack assemble(Container pInv, RegistryAccess pRegistryAccess) {
|
2021-10-24 18:49:48 +02:00
|
|
|
return ItemStack.EMPTY;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean canCraftInDimensions(int pWidth, int pHeight) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-11-13 17:30:53 +01:00
|
|
|
@Nonnull
|
2024-03-03 01:20:53 +01:00
|
|
|
public ItemStack getResultItem(RegistryAccess pRegistryAccess) {
|
2024-03-04 20:21:48 +01:00
|
|
|
return this.outputs.get(0).stack.copy();
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-11-13 17:30:53 +01:00
|
|
|
@Nonnull
|
2024-03-02 21:23:08 +01:00
|
|
|
public RecipeSerializer<?> getSerializer() {
|
2021-10-24 18:49:48 +02:00
|
|
|
return ActuallyRecipes.CRUSHING_RECIPE.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2021-11-13 17:30:53 +01:00
|
|
|
@Nonnull
|
2024-03-02 21:23:08 +01:00
|
|
|
public RecipeType<?> getType() {
|
2024-03-03 17:48:28 +01:00
|
|
|
return ActuallyRecipes.Types.CRUSHING.get();
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public ItemStack getOutputOne() {
|
2024-03-04 20:21:48 +01:00
|
|
|
return this.outputs.get(0).stack;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public ItemStack getOutputTwo() {
|
2024-03-04 20:21:48 +01:00
|
|
|
return this.outputs.get(1).stack;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
2021-11-13 17:30:53 +01:00
|
|
|
public float getFirstChance() {
|
2024-03-04 20:21:48 +01:00
|
|
|
return this.outputs.get(0).chance;
|
2021-11-13 17:30:53 +01:00
|
|
|
}
|
|
|
|
public float getSecondChance() {
|
2024-03-04 20:21:48 +01:00
|
|
|
return this.outputs.get(1).chance;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public Ingredient getInput() {
|
|
|
|
return this.input;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
public record CrushingResult(ItemStack stack, float chance) {
|
|
|
|
public static final CrushingResult EMPTY = new CrushingResult(ItemStack.EMPTY, 0.0F);
|
|
|
|
};
|
2021-11-13 17:30:53 +01:00
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
public static class Serializer implements RecipeSerializer<CrushingRecipe> {
|
|
|
|
private static final Codec<CrushingResult> RESULT_CODEC = RecordCodecBuilder.create(
|
|
|
|
instance -> instance.group(
|
2024-03-04 22:52:10 +01:00
|
|
|
ItemStack.CODEC.fieldOf("result").forGetter(result -> result.stack),
|
2024-03-04 20:21:48 +01:00
|
|
|
Codec.FLOAT.optionalFieldOf("chance", 1.0F).forGetter(recipe -> recipe.chance)
|
|
|
|
)
|
|
|
|
.apply(instance, CrushingResult::new)
|
|
|
|
);
|
|
|
|
|
|
|
|
private static final Codec<CrushingRecipe> CODEC = RecordCodecBuilder.create(
|
|
|
|
instance -> instance.group(
|
|
|
|
Ingredient.CODEC_NONEMPTY.fieldOf("ingredient").forGetter(recipe -> recipe.input),
|
|
|
|
RESULT_CODEC
|
|
|
|
.listOf()
|
|
|
|
.fieldOf("result")
|
|
|
|
.flatXmap(
|
|
|
|
array -> {
|
|
|
|
CrushingResult[] resultArray = array.toArray(CrushingResult[]::new);
|
|
|
|
NonNullList<CrushingResult> results = NonNullList.withSize(2, CrushingResult.EMPTY);
|
|
|
|
if (resultArray.length < 1) {
|
|
|
|
return DataResult.error(() -> "Recipe must contain at least 1 result");
|
|
|
|
} else if (resultArray.length > 2) {
|
|
|
|
return DataResult.error(() -> "Too many results for crushing recipe. The maximum is: 2");
|
|
|
|
} else {
|
|
|
|
for (int i = 0; i < resultArray.length; i++) {
|
|
|
|
results.set(i, resultArray[i]);
|
|
|
|
}
|
|
|
|
return DataResult.success(results);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
DataResult::success
|
|
|
|
)
|
|
|
|
.forGetter(recipe -> recipe.outputs)
|
|
|
|
)
|
|
|
|
.apply(instance, CrushingRecipe::new)
|
|
|
|
);
|
2021-10-24 18:49:48 +02:00
|
|
|
|
|
|
|
@Override
|
2024-03-04 20:21:48 +01:00
|
|
|
public Codec<CrushingRecipe> codec() {
|
|
|
|
return CODEC;
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
// @Override
|
|
|
|
// @Nonnull
|
|
|
|
// public CrushingRecipe fromJson(@Nonnull ResourceLocation pRecipeId, @Nonnull JsonObject pJson) {
|
|
|
|
// Ingredient ingredient = Ingredient.fromJson(GsonHelper.getAsJsonObject(pJson, "ingredient"));
|
|
|
|
//
|
|
|
|
// JsonArray resultList = GsonHelper.getAsJsonArray(pJson, "result");
|
|
|
|
// if (resultList.size() < 1)
|
|
|
|
// throw new IllegalStateException(pRecipeId.toString() + ": Recipe must contain at least 1 result item");
|
|
|
|
//
|
|
|
|
// JsonObject result1 = resultList.get(0).getAsJsonObject();
|
|
|
|
// int count1 = GsonHelper.getAsInt(result1, "count", 0);
|
|
|
|
// ItemStack output1 = new ItemStack(GsonHelper.getAsItem(result1, "item"), count1);
|
|
|
|
// float chance1 = GsonHelper.getAsFloat(result1, "chance");
|
|
|
|
//
|
|
|
|
// ItemStack output2 = ItemStack.EMPTY;
|
|
|
|
// float chance2 = 1.0f;
|
|
|
|
// if (resultList.size() > 1) {
|
|
|
|
// JsonObject result2 = resultList.get(1).getAsJsonObject();
|
|
|
|
// int count2 = GsonHelper.getAsInt(result2, "count", 0);
|
|
|
|
// output2 = new ItemStack(GsonHelper.getAsItem(result2, "item"), count2);
|
|
|
|
// chance2 = GsonHelper.getAsFloat(result2, "chance");
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// return new CrushingRecipe(pRecipeId, ingredient, output1, chance1, output2, chance2);
|
|
|
|
// }
|
2021-10-24 18:49:48 +02:00
|
|
|
|
|
|
|
@Override
|
2024-03-04 20:21:48 +01:00
|
|
|
public CrushingRecipe fromNetwork(@Nonnull FriendlyByteBuf pBuffer) {
|
|
|
|
Ingredient ingredient = Ingredient.fromNetwork(pBuffer);
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
int i = pBuffer.readVarInt();
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
NonNullList<CrushingResult> nonnulllist = NonNullList.withSize(i, CrushingResult.EMPTY);
|
|
|
|
for (int j = 0; j < nonnulllist.size(); ++j) {
|
|
|
|
nonnulllist.set(j, new CrushingResult(pBuffer.readItem(), pBuffer.readFloat()));
|
|
|
|
}
|
2021-10-24 18:49:48 +02:00
|
|
|
|
2024-03-04 20:21:48 +01:00
|
|
|
return new CrushingRecipe(ingredient, nonnulllist);
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2024-03-04 20:21:48 +01:00
|
|
|
public void toNetwork(@Nonnull FriendlyByteBuf pBuffer, CrushingRecipe pRecipe) {
|
|
|
|
pRecipe.input.toNetwork(pBuffer);
|
|
|
|
pBuffer.writeVarInt(pRecipe.outputs.size());
|
|
|
|
for (CrushingResult result : pRecipe.outputs) {
|
|
|
|
pBuffer.writeItem(result.stack);
|
|
|
|
pBuffer.writeFloat(result.chance);
|
|
|
|
}
|
2021-10-24 18:49:48 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|