lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Creation of 1.16.3 branch

Browse source 
Initial publishing of the 1.16.3 branch of the mod. A lot of systems are missing (such as Rituals and Living Armour), but enough is present for a decent Alpha release.
This commit is contained in:
WayofTime 2020-10-24 08:59:04 -04:00
parent 0e02b983f1
commit d617911d7a
1662 changed files with 18791 additions and 85075 deletions
Download patch file Download diff file Expand all files Collapse all files

51
src/main/java/wayoftime/bloodmagic/common/data/GeneratorBaseRecipes.java Normal file
View file

@ -0,0 +1,51 @@
package wayoftime.bloodmagic.common.data;
import java.util.function.Consumer;
import net.minecraft.data.DataGenerator;
import net.minecraft.data.IFinishedRecipe;
import net.minecraft.data.ShapedRecipeBuilder;
import net.minecraft.item.Items;
import net.minecraft.item.crafting.Ingredient;
import net.minecraftforge.common.Tags;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
import wayoftime.bloodmagic.common.data.recipe.BaseRecipeProvider;
import wayoftime.bloodmagic.common.item.BloodMagicItems;
import wayoftime.bloodmagic.core.recipe.IngredientBloodOrb;
public class GeneratorBaseRecipes extends BaseRecipeProvider
{
public GeneratorBaseRecipes(DataGenerator gen)
{
super(gen, BloodMagic.MODID);
}
@Override
protected void registerRecipes(Consumer<IFinishedRecipe> consumer)
{
addVanillaRecipes(consumer);
addBloodOrbRecipes(consumer);
}
private void addVanillaRecipes(Consumer<IFinishedRecipe> consumer)
{
ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.SACRIFICIAL_DAGGER.get()).key('g', Tags.Items.GLASS).key('G', Tags.Items.INGOTS_GOLD).key('i', Tags.Items.INGOTS_IRON).patternLine("ggg").patternLine(" Gg").patternLine("i g").addCriterion("has_glass", hasItem(Items.GLASS)).build(consumer, BloodMagic.rl("sacrificial_dagger"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.BLOOD_ALTAR.get()).key('a', Tags.Items.STONE).key('b', Items.FURNACE).key('c', Tags.Items.INGOTS_GOLD).key('d', BloodMagicItems.MONSTER_SOUL_RAW.get()).patternLine("a a").patternLine("aba").patternLine("cdc").addCriterion("has_will", hasItem(BloodMagicItems.MONSTER_SOUL_RAW.get())).build(consumer, BloodMagic.rl("blood_altar"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SOUL_FORGE.get()).key('s', Tags.Items.STONE).key('g', Tags.Items.INGOTS_GOLD).key('i', Tags.Items.INGOTS_IRON).key('o', Tags.Items.STORAGE_BLOCKS_IRON).patternLine("i i").patternLine("sgs").patternLine("sos").addCriterion("has_gold", hasItem(Items.GOLD_INGOT)).build(consumer, BloodMagic.rl("soul_forge"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicItems.SOUL_SNARE.get(), 4).key('r', Tags.Items.DUSTS_REDSTONE).key('s', Tags.Items.STRING).key('i', Tags.Items.INGOTS_IRON).patternLine("sis").patternLine("iri").patternLine("sis").addCriterion("has_redstone", hasItem(Items.REDSTONE)).build(consumer, BloodMagic.rl("soul_snare"));
}
private void addBloodOrbRecipes(Consumer<IFinishedRecipe> consumer)
{
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.BLANK_RUNE.get()).key('a', Tags.Items.STONE).key('s', Ingredient.fromItems(BloodMagicItems.SLATE.get())).key('o', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).patternLine("aaa").patternLine("sos").patternLine("aaa").addCriterion("has_weak_orb", hasItem(BloodMagicItems.WEAK_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_blank"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('a', Tags.Items.STONE).key('b', Ingredient.fromItems(BloodMagicItems.SLATE.get())).key('c', Ingredient.fromItems(Items.SUGAR)).key('d', BloodMagicBlocks.BLANK_RUNE.get()).patternLine("aba").patternLine("cdc").patternLine("aba").addCriterion("has_blank_rune", hasItem(BloodMagicItems.BLANK_RUNE_ITEM.get())).build(consumer, BloodMagic.rl("blood_rune_speed"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SACRIFICE_RUNE.get()).key('a', Tags.Items.STONE).key('b', BloodMagicItems.REINFORCED_SLATE.get()).key('c', Tags.Items.INGOTS_GOLD).key('d', BloodMagicBlocks.BLANK_RUNE.get()).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_APPRENTICE.get())).patternLine("aba").patternLine("cdc").patternLine("aea").addCriterion("has_apprentice_orb", hasItem(BloodMagicItems.APPRENTICE_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_sacrifice"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SELF_SACRIFICE_RUNE.get()).key('a', Tags.Items.STONE).key('b', Ingredient.fromItems(BloodMagicItems.REINFORCED_SLATE.get())).key('c', Ingredient.fromItems(Items.GLOWSTONE_DUST)).key('d', Ingredient.fromItems(BloodMagicItems.BLANK_RUNE_ITEM.get())).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_APPRENTICE.get())).patternLine("aba").patternLine("cdc").patternLine("aea").addCriterion("has_apprentice_orb", hasItem(BloodMagicItems.APPRENTICE_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_self_sacrifice"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.CAPACITY_RUNE.get()).key('a', Tags.Items.STONE).key('b', Items.BUCKET).key('c', BloodMagicBlocks.BLANK_RUNE.get()).key('d', BloodMagicItems.IMBUED_SLATE.get()).patternLine("aba").patternLine("bcb").patternLine("ada").addCriterion("has_imbued_slate", hasItem(BloodMagicItems.IMBUED_SLATE.get())).build(consumer, BloodMagic.rl("blood_rune_capacity"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.ORB_RUNE.get()).key('a', Tags.Items.STONE).key('b', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).key('c', BloodMagicBlocks.BLANK_RUNE.get()).key('d', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_MASTER.get())).patternLine("aba").patternLine("cdc").patternLine("aba").addCriterion("has_master_orb", hasItem(BloodMagicItems.MASTER_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_orb"));
ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.CHARGING_RUNE.get()).key('R', Tags.Items.DUSTS_REDSTONE).key('r', BloodMagicBlocks.BLANK_RUNE.get()).key('s', BloodMagicItems.DEMONIC_SLATE.get()).key('e', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_MASTER.get())).key('G', Tags.Items.DUSTS_GLOWSTONE).patternLine("RsR").patternLine("GrG").patternLine("ReR").addCriterion("has_master_orb", hasItem(BloodMagicItems.MASTER_BLOOD_ORB.get())).build(consumer, BloodMagic.rl("blood_rune_charging"));
// ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('s', Items.GLASS).key('o', Ingredient.fromItems(Items.DIAMOND)).patternLine("sss").patternLine("sos").patternLine("sss").addCriterion("has_diamond", hasItem(Items.DIAMOND)).build(consumer, new ResourceLocation(BloodMagic.MODID, "speed_rune_from_standard"));
// ShapedRecipeBuilder.shapedRecipe(BloodMagicBlocks.SPEED_RUNE.get()).key('s', Items.GLASS).key('o', IngredientBloodOrb.fromOrb(BloodMagicItems.ORB_WEAK.get())).patternLine("sss").patternLine("sos").patternLine("sss").addCriterion("has_diamond", hasItem(Items.DIAMOND)).build(consumer, new ResourceLocation(BloodMagic.MODID, "speed_rune_from_orb"));
}
}

38
src/main/java/wayoftime/bloodmagic/common/data/GeneratorBlockStates.java Normal file
View file

@ -0,0 +1,38 @@
package wayoftime.bloodmagic.common.data;
import net.minecraft.block.Block;
import net.minecraft.data.DataGenerator;
import net.minecraftforge.client.model.generators.BlockStateProvider;
import net.minecraftforge.client.model.generators.ConfiguredModel;
import net.minecraftforge.common.data.ExistingFileHelper;
import net.minecraftforge.fml.RegistryObject;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
public class GeneratorBlockStates extends BlockStateProvider
{
public GeneratorBlockStates(DataGenerator gen, ExistingFileHelper exFileHelper)
{
super(gen, BloodMagic.MODID, exFileHelper);
}
@Override
protected void registerStatesAndModels()
{
// buildCubeAll(BloodMagicBlocks.TARTARICFORGE.get());
// buildCubeAll(BloodMagicBlocks.SPEED_RUNE.get());
for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
{
buildCubeAll(block.get());
}
buildCubeAll(BloodMagicBlocks.BLOOD_LIGHT.get());
}
private void buildCubeAll(Block block)
{
getVariantBuilder(block).forAllStates(state -> ConfiguredModel.builder().modelFile(cubeAll(block)).build());
}
}

105
src/main/java/wayoftime/bloodmagic/common/data/GeneratorItemModels.java Normal file
View file

@ -0,0 +1,105 @@
package wayoftime.bloodmagic.common.data;
import net.minecraft.block.Block;
import net.minecraft.data.DataGenerator;
import net.minecraft.item.Item;
import net.minecraftforge.client.model.generators.ItemModelBuilder;
import net.minecraftforge.client.model.generators.ItemModelProvider;
import net.minecraftforge.client.model.generators.ModelFile;
import net.minecraftforge.common.data.ExistingFileHelper;
import net.minecraftforge.fml.RegistryObject;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
import wayoftime.bloodmagic.common.item.BloodMagicItems;
import wayoftime.bloodmagic.will.EnumDemonWillType;
public class GeneratorItemModels extends ItemModelProvider
{
public GeneratorItemModels(DataGenerator generator, ExistingFileHelper existingFileHelper)
{
super(generator, BloodMagic.MODID, existingFileHelper);
}
@Override
protected void registerModels()
{
// registerBlockModel(BloodMagicBlocks.TARTARICFORGE.get());
// registerBlockModel(BloodMagicBlocks.SPEED_RUNE.get());
for (RegistryObject<Item> item : BloodMagicItems.BASICITEMS.getEntries())
{
registerBasicItem(item.get());
}
for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
{
registerBlockModel(block.get());
}
registerToggleableItem(BloodMagicItems.GREEN_GROVE_SIGIL.get());
registerToggleableItem(BloodMagicItems.FAST_MINER_SIGIL.get());
registerToggleableItem(BloodMagicItems.MAGNETISM_SIGIL.get());
registerToggleableItem(BloodMagicItems.ICE_SIGIL.get());
registerDemonWillVariantItem(BloodMagicItems.PETTY_GEM.get());
registerDemonWillVariantItem(BloodMagicItems.LESSER_GEM.get());
registerDemonWillVariantItem(BloodMagicItems.COMMON_GEM.get());
registerDemonSword(BloodMagicItems.SENTIENT_SWORD.get());
}
private void registerBlockModel(Block block)
{
String path = block.getRegistryName().getPath();
getBuilder(path).parent(new ModelFile.UncheckedModelFile(modLoc("block/" + path)));
}
private void registerBasicItem(Item item)
{
String path = item.getRegistryName().getPath();
singleTexture(path, mcLoc("item/handheld"), "layer0", modLoc("item/" + path));
}
private void registerToggleableItem(Item item)
{
String path = item.getRegistryName().getPath();
ModelFile activatedFile = singleTexture("item/variants/" + path + "_activated", mcLoc("item/handheld"), "layer0", modLoc("item/" + path + "_activated"));
ModelFile deactivatedFile = singleTexture("item/variants/" + path + "_deactivated", mcLoc("item/handheld"), "layer0", modLoc("item/" + path + "_deactivated"));
getBuilder(path).override().predicate(BloodMagic.rl("active"), 0).model(deactivatedFile).end().override().predicate(BloodMagic.rl("active"), 1).model(activatedFile).end();
}
private void registerDemonWillVariantItem(Item item)
{
String path = item.getRegistryName().getPath();
ItemModelBuilder builder = getBuilder(path);
for (EnumDemonWillType type : EnumDemonWillType.values())
{
String name = "";
if (type.ordinal() != 0)
{
name = "_" + type.name().toLowerCase();
}
ModelFile willFile = singleTexture("item/variants/" + path + name, mcLoc("item/handheld"), "layer0", modLoc("item/" + path + name));
builder = builder.override().predicate(BloodMagic.rl("type"), type.ordinal()).model(willFile).end();
}
}
private void registerDemonSword(Item item)
{
String path = item.getRegistryName().getPath();
ItemModelBuilder builder = getBuilder(path);
for (int i = 0; i <= 1; i++)
{
for (EnumDemonWillType type : EnumDemonWillType.values())
{
String name = i == 0 ? "_deactivated" : "_activated";
if (type.ordinal() != 0)
{
name = "_" + type.name().toLowerCase() + name;
}
ModelFile willFile = singleTexture("item/variants/" + path + name, mcLoc("item/handheld"), "layer0", modLoc("item/" + path + name));
builder = builder.override().predicate(BloodMagic.rl("type"), type.ordinal()).predicate(BloodMagic.rl("active"), i).model(willFile).end();
}
}
}
}

161
src/main/java/wayoftime/bloodmagic/common/data/GeneratorLanguage.java Normal file
View file

@ -0,0 +1,161 @@
package wayoftime.bloodmagic.common.data;
import net.minecraft.data.DataGenerator;
import net.minecraftforge.common.data.LanguageProvider;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
import wayoftime.bloodmagic.common.item.BloodMagicItems;
public class GeneratorLanguage extends LanguageProvider
{
public GeneratorLanguage(DataGenerator gen)
{
super(gen, BloodMagic.MODID, "en_us");
}
@Override
protected void addTranslations()
{
// Creative Tab
add("itemGroup.bloodmagic.creativeTab", "Blood Magic");
// Tile Entitites
add("tile.bloodmagic.soulforge.name", "Hellfire Forge");
// Blood Orb tooltips
add("tooltip.bloodmagic.extraInfo", "&9-Hold shift for more info-");
add("tooltip.bloodmagic.orb.desc", "Stores raw Life Essence");
add("tooltip.bloodmagic.orb.owner", "Added by: %s");
add("tooltip.bloodmagic.currentOwner", "Current owner: %s");
add("tooltip.bloodmagic.currentTier", "Current tier: %d");
add("tooltip.bloodmagic.config.disabled", "Currently disabled in the Config");
add("tooltip.bloodmagic.tier", "Tier %d");
// Sigil tooltips
add("tooltip.bloodmagic.sigil.divination.desc", "Peer into the soul");
add("tooltip.bloodmagic.sigil.divination.otherNetwork", "Peering into the soul of %s");
add("tooltip.bloodmagic.sigil.divination.currentAltarTier", "Current Tier: %d");
add("tooltip.bloodmagic.sigil.divination.currentEssence", "Current Essence: %d LP");
add("tooltip.bloodmagic.sigil.divination.currentAltarCapacity", "Current Capacity: %d LP");
add("tooltip.bloodmagic.sigil.divination.currentTranquility", "Current Tranquility: %d");
// add("tooltip.bloodmagic.sigil.divination.currentInversion", "Current Inversion: %d");
add("tooltip.bloodmagic.sigil.divination.currentBonus", "Current Bonus: +%d%%");
add("tooltip.bloodmagic.decoration.safe", "Safe for decoration");
add("tooltip.bloodmagic.decoration.notSafe", "Dangerous for decoration");
// General Tooltips
add("tooltip.bloodmagic.arcaneAshes", "Ashes used to draw an alchemy circle");
add("tooltip.bloodmagic.will", "Will Quality: %s");
add("tooltip.bloodmagic.sentientSword.desc", "Uses demon will to unleash its full potential.");
add("tooltip.bloodmagic.sentientAxe.desc", "Uses demon will to unleash its full potential.");
add("tooltip.bloodmagic.sentientPickaxe.desc", "Uses demon will to unleash its full potential.");
add("tooltip.bloodmagic.sentientShovel.desc", "Uses demon will to unleash its full potential.");
add("tooltip.bloodmagic.soulGem.petty", "A gem used to contain a little will");
add("tooltip.bloodmagic.soulGem.lesser", "A gem used to contain some will");
add("tooltip.bloodmagic.soulGem.common", "A gem used to contain more will");
add("tooltip.bloodmagic.soulGem.greater", "A gem used to contain a greater amount of will");
add("tooltip.bloodmagic.soulGem.grand", "A gem used to contain a large amount of will");
add("tooltip.bloodmagic.soulSnare.desc", "Throw at a monster and then kill them to obtain their demonic will");
add("tooltip.bloodmagic.currentType.default", "Contains: Raw Will");
add("tooltip.bloodmagic.currentType.corrosive", "Contains: Corrosive Will");
add("tooltip.bloodmagic.currentType.destructive", "Contains: Destructive Will");
add("tooltip.bloodmagic.currentType.vengeful", "Contains: Vengeful Will");
add("tooltip.bloodmagic.currentType.steadfast", "Contains: Steadfast Will");
add("tooltip.bloodmagic.currentBaseType.default", "Raw");
add("tooltip.bloodmagic.currentBaseType.corrosive", "Corrosive");
add("tooltip.bloodmagic.currentBaseType.destructive", "Destructive");
add("tooltip.bloodmagic.currentBaseType.vengeful", "Vengeful");
add("tooltip.bloodmagic.currentBaseType.steadfast", "Steadfast");
add("tooltip.bloodmagic.sacrificialdagger.desc", "Just a prick of the finger will suffice...");
add("tooltip.bloodmagic.slate.desc", "Infused stone inside of a Blood Altar");
add("tooltip.bloodmagic.sigil.water.desc", "Infinite water, anyone?");
add("tooltip.bloodmagic.sigil.lava.desc", "HOT! DO NOT EAT");
add("tooltip.bloodmagic.sigil.void.desc", "Better than a Swiffer®!");
add("tooltip.bloodmagic.sigil.greengrove.desc", "Environmentally friendly");
add("tooltip.bloodmagic.sigil.magnetism.desc", "I have a very magnetic personality");
add("tooltip.bloodmagic.sigil.fastminer.desc", "Keep mining, and mining...");
add("tooltip.bloodmagic.sigil.air.desc", "I feel lighter already...");
add("tooltip.bloodmagic.sigil.bloodlight.desc", "I see a light!");
add("itemGroup.bloodmagictab", "Blood Magic");
// Block names
addBlock(BloodMagicBlocks.BLANK_RUNE, "Blank Rune");
addBlock(BloodMagicBlocks.SPEED_RUNE, "Speed Rune");
addBlock(BloodMagicBlocks.SACRIFICE_RUNE, "Rune of Sacrifice");
addBlock(BloodMagicBlocks.SELF_SACRIFICE_RUNE, "Rune of Self Sacrifice");
addBlock(BloodMagicBlocks.DISPLACEMENT_RUNE, "DisplacementRune");
addBlock(BloodMagicBlocks.CAPACITY_RUNE, "Rune of Capacity");
addBlock(BloodMagicBlocks.AUGMENTED_CAPACITY_RUNE, "Rune of Augmented Capacity");
addBlock(BloodMagicBlocks.ORB_RUNE, "Rune of the Orb");
addBlock(BloodMagicBlocks.ACCELERATION_RUNE, "Acceleration Rune");
addBlock(BloodMagicBlocks.CHARGING_RUNE, "Charging Rune");
addBlock(BloodMagicBlocks.BLOOD_ALTAR, "Blood Altar");
addBlock(BloodMagicBlocks.SOUL_FORGE, "Hellfire Forge");
// Item names
addItem(BloodMagicItems.WEAK_BLOOD_ORB, "Weak Blood Orb");
addItem(BloodMagicItems.APPRENTICE_BLOOD_ORB, "Apprentice Blood Orb");
addItem(BloodMagicItems.MAGICIAN_BLOOD_ORB, "Magician Blood Orb");
addItem(BloodMagicItems.MASTER_BLOOD_ORB, "Master Blood Orb");
addItem(BloodMagicItems.DIVINATION_SIGIL, "Divination Sigil");
addItem(BloodMagicItems.WATER_SIGIL, "Water Sigil");
addItem(BloodMagicItems.LAVA_SIGIL, "Lava Sigil");
addItem(BloodMagicItems.VOID_SIGIL, "Void Sigil");
addItem(BloodMagicItems.GREEN_GROVE_SIGIL, "Sigil of the Green Grove");
addItem(BloodMagicItems.FAST_MINER_SIGIL, "Sigil of the Fast Miner");
addItem(BloodMagicItems.MAGNETISM_SIGIL, "Sigil of Magnetism");
addItem(BloodMagicItems.ICE_SIGIL, "Sigil of the Frozen Lake");
addItem(BloodMagicItems.AIR_SIGIL, "Air Sigil");
addItem(BloodMagicItems.BLOOD_LIGHT_SIGIL, "Sigil of the Blood Lamp");
addItem(BloodMagicBlocks.LIFE_ESSENCE_BUCKET, "Bucket of Life");
addItem(BloodMagicItems.ARCANE_ASHES, "Arcane Ashes");
addItem(BloodMagicItems.SLATE, "Blank Slate");
addItem(BloodMagicItems.REINFORCED_SLATE, "Reinforced Slate");
addItem(BloodMagicItems.IMBUED_SLATE, "Imbued Slate");
addItem(BloodMagicItems.DEMONIC_SLATE, "Demonic Slate");
addItem(BloodMagicItems.ETHEREAL_SLATE, "Ethereal Slate");
addItem(BloodMagicItems.DAGGER_OF_SACRIFICE, "Dagger of Sacrifice");
addItem(BloodMagicItems.SACRIFICIAL_DAGGER, "Sacrificial Knife");
addItem(BloodMagicItems.REAGENT_WATER, "Water Reagent");
addItem(BloodMagicItems.REAGENT_LAVA, "Lava Reagent");
addItem(BloodMagicItems.REAGENT_FAST_MINER, "Mining Reagent");
addItem(BloodMagicItems.REAGENT_GROWTH, "Growth Reagent");
addItem(BloodMagicItems.REAGENT_VOID, "Void Reagent");
addItem(BloodMagicItems.REAGENT_MAGNETISM, "Magnetism Reagent");
addItem(BloodMagicItems.REAGENT_AIR, "Air Reagent");
addItem(BloodMagicItems.REAGENT_BLOOD_LIGHT, "Blood Lamp Reagent");
addItem(BloodMagicItems.PETTY_GEM, "Petty Tartaric Gem");
addItem(BloodMagicItems.LESSER_GEM, "Lesser Tartaric Gem");
addItem(BloodMagicItems.COMMON_GEM, "Common Tartaric Gem");
addItem(BloodMagicItems.MONSTER_SOUL_RAW, "Demon Will");
addItem(BloodMagicItems.MONSTER_SOUL_CORROSIVE, "Demon Will");
addItem(BloodMagicItems.MONSTER_SOUL_DESTRUCTIVE, "Demon Will");
addItem(BloodMagicItems.MONSTER_SOUL_STEADFAST, "Demon Will");
addItem(BloodMagicItems.MONSTER_SOUL_VENGEFUL, "Demon Will");
addItem(BloodMagicItems.SOUL_SNARE, "Soul Snare");
addItem(BloodMagicItems.SENTIENT_SWORD, "Sentient Sword");
// addItem(BloodMagicItems , "");
// JEI
add("jei.bloodmagic.recipe.minimumsouls", "Minimum: %s Will");
add("jei.bloodmagic.recipe.soulsdrained", "Drained: %s Will");
add("jei.bloodmagic.recipe.requiredlp", "LP: %d");
add("jei.bloodmagic.recipe.requiredtier", "Tier: %d");
add("jei.bloodmagic.recipe.consumptionrate", "Consumption: %s LP/t");
add("jei.bloodmagic.recipe.drainrate", "Drain: %s LP/t");
add("jei.bloodmagic.recipe.altar", "Blood Altar");
add("jei.bloodmagic.recipe.soulforge", "Hellfire Forge");
add("jei.bloodmagic.recipe.alchemyarraycrafting", "Alchemy Array");
}
}

99
src/main/java/wayoftime/bloodmagic/common/data/GeneratorLootTable.java Normal file
View file

@ -0,0 +1,99 @@
package wayoftime.bloodmagic.common.data;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import com.google.common.collect.ImmutableList;
import com.mojang.datafixers.util.Pair;
import net.minecraft.block.Block;
import net.minecraft.data.DataGenerator;
import net.minecraft.data.LootTableProvider;
import net.minecraft.data.loot.BlockLootTables;
import net.minecraft.loot.LootParameterSet;
import net.minecraft.loot.LootParameterSets;
import net.minecraft.loot.LootPool;
import net.minecraft.loot.LootTable;
import net.minecraft.loot.LootTableManager;
import net.minecraft.loot.ValidationTracker;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.fml.RegistryObject;
import net.minecraftforge.registries.ForgeRegistries;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.block.BloodMagicBlocks;
public class GeneratorLootTable extends LootTableProvider
{
public GeneratorLootTable(DataGenerator dataGeneratorIn)
{
super(dataGeneratorIn);
}
@Override
protected List<Pair<Supplier<Consumer<BiConsumer<ResourceLocation, LootTable.Builder>>>, LootParameterSet>> getTables()
{
return ImmutableList.of(Pair.of(Blocks::new, LootParameterSets.BLOCK));
}
private static class Blocks extends BlockLootTables
{
@Override
protected void addTables()
{
for (RegistryObject<Block> block : BloodMagicBlocks.BASICBLOCKS.getEntries())
{
this.registerDropSelfLootTable(block.get());
}
this.registerDropSelfLootTable(BloodMagicBlocks.BLOOD_ALTAR.get());
registerNoDropLootTable(BloodMagicBlocks.ALCHEMY_ARRAY.get());
registerNoDropLootTable(BloodMagicBlocks.BLOOD_LIGHT.get());
this.registerDropSelfLootTable(BloodMagicBlocks.SOUL_FORGE.get());
// LootPool.Builder builder = LootPool.builder().name(ModBlocks.GOO_BLOCK.get().getRegistryName().toString()).rolls(ConstantRange.of(1)).acceptCondition(SurvivesExplosion.builder()).addEntry(ItemLootEntry.builder(ModItems.GOO_RESIDUE.get()));
// this.registerLootTable(ModBlocks.GOO_BLOCK.get(), LootTable.builder().addLootPool(builder));
//
// LootPool.Builder builder2 = LootPool.builder().name(ModBlocks.GOO_BLOCK_TERRAIN.get().getRegistryName().toString()).rolls(ConstantRange.of(1)).acceptCondition(SurvivesExplosion.builder()).addEntry(ItemLootEntry.builder(ModItems.GOO_RESIDUE.get()));
// this.registerLootTable(ModBlocks.GOO_BLOCK_TERRAIN.get(), LootTable.builder().addLootPool(builder2));
//
// this.registerDropSelfLootTable(ModBlocks.GOO_BLOCK_POISON.get());
// this.registerDropSelfLootTable(ModBlocks.GNT_BLOCK_T1.get());
// this.registerDropSelfLootTable(ModBlocks.GNT_BLOCK_T2.get());
// this.registerDropSelfLootTable(ModBlocks.GNT_BLOCK_T3.get());
// this.registerDropSelfLootTable(ModBlocks.GNT_BLOCK_T4.get());
// this.registerDropSelfLootTable(ModBlocks.TURRET_BLOCK.get());
// this.registerDropSelfLootTable(ModBlocks.ZAPPER_TURRET_BLOCK.get());
// this.registerDropSelfLootTable(ModBlocks.ANTI_GOO_BEACON.get());
// this.registerDropSelfLootTable(ModBlocks.ANTI_GOO_FIELD_GEN.get());
// this.registerDropSelfLootTable(ModBlocks.GOOLIMINATIONFIELDGEN.get());
// this.registerDropSelfLootTable(ModBlocks.GOO_DETECTOR.get());
// this.registerDropping(ModBlocks.GOO_RENDER.get(), ItemStack.EMPTY.getItem());
// // this.registerDropping(ModBlocks.GOO_RENDER_BURST.get(),
// // ItemStack.EMPTY.getItem());
// this.registerDropping(ModBlocks.GOO_RENDER_TERRAIN.get(), ItemStack.EMPTY.getItem());
}
private void registerNoDropLootTable(Block block)
{
LootPool.Builder builder = LootPool.builder().name(block.getRegistryName().toString());
this.registerLootTable(block, LootTable.builder().addLootPool(builder));
}
@Override
protected Iterable<Block> getKnownBlocks()
{
return ForgeRegistries.BLOCKS.getValues().stream().filter(b -> b.getRegistryName().getNamespace().equals(BloodMagic.MODID)).collect(Collectors.toList());
}
}
@Override
protected void validate(Map<ResourceLocation, LootTable> map, ValidationTracker validationtracker)
{
map.forEach((name, table) -> LootTableManager.validateLootTable(validationtracker, name, table));
}
}

44
src/main/java/wayoftime/bloodmagic/common/data/recipe/BaseRecipeProvider.java Normal file
View file

@ -0,0 +1,44 @@
package wayoftime.bloodmagic.common.data.recipe;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import net.minecraft.data.DataGenerator;
import net.minecraft.data.IFinishedRecipe;
import net.minecraft.data.RecipeProvider;
import wayoftime.bloodmagic.common.recipe.ISubRecipeProvider;
public abstract class BaseRecipeProvider extends RecipeProvider
{
private final String modid;
public BaseRecipeProvider(DataGenerator gen, String modid)
{
super(gen);
this.modid = modid;
}
@Override
public String getName()
{
return super.getName() + modid;
}
@Override
protected void registerRecipes(Consumer<IFinishedRecipe> consumer)
{
getSubRecipeProviders().forEach(subRecipeProvider -> subRecipeProvider.addRecipes(consumer));
}
/**
* Gets all the sub/offloaded recipe providers that this recipe provider has.
*
* @implNote This is only called once per provider so there is no need to bother
* caching the list that this returns
*/
protected List<ISubRecipeProvider> getSubRecipeProviders()
{
return Collections.emptyList();
}
}

145
src/main/java/wayoftime/bloodmagic/common/data/recipe/BloodMagicRecipeBuilder.java Normal file
View file

@ -0,0 +1,145 @@
package wayoftime.bloodmagic.common.data.recipe;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import net.minecraft.advancements.Advancement;
import net.minecraft.advancements.AdvancementRewards;
import net.minecraft.advancements.ICriterionInstance;
import net.minecraft.advancements.IRequirementsStrategy;
import net.minecraft.advancements.criterion.RecipeUnlockedTrigger;
import net.minecraft.data.IFinishedRecipe;
import net.minecraft.item.crafting.IRecipeSerializer;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.common.crafting.CraftingHelper;
import net.minecraftforge.common.crafting.conditions.ICondition;
import net.minecraftforge.registries.ForgeRegistries;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.util.Constants;
public abstract class BloodMagicRecipeBuilder<BUILDER extends BloodMagicRecipeBuilder<BUILDER>>
{
protected static ResourceLocation bmSerializer(String name)
{
return new ResourceLocation(BloodMagic.MODID, name);
}
protected final List<ICondition> conditions = new ArrayList<>();
protected final Advancement.Builder advancementBuilder = Advancement.Builder.builder();
protected final ResourceLocation serializerName;
protected BloodMagicRecipeBuilder(ResourceLocation serializerName)
{
this.serializerName = serializerName;
}
public BUILDER addCriterion(RecipeCriterion criterion)
{
return addCriterion(criterion.name, criterion.criterion);
}
public BUILDER addCriterion(String name, ICriterionInstance criterion)
{
advancementBuilder.withCriterion(name, criterion);
return (BUILDER) this;
}
public BUILDER addCondition(ICondition condition)
{
conditions.add(condition);
return (BUILDER) this;
}
protected boolean hasCriteria()
{
return !advancementBuilder.getCriteria().isEmpty();
}
protected abstract RecipeResult getResult(ResourceLocation id);
protected void validate(ResourceLocation id)
{
}
public void build(Consumer<IFinishedRecipe> consumer, ResourceLocation id)
{
validate(id);
if (hasCriteria())
{
// If there is a way to "unlock" this recipe then add an advancement with the
// criteria
advancementBuilder.withParentId(new ResourceLocation("recipes/root")).withCriterion("has_the_recipe", RecipeUnlockedTrigger.create(id)).withRewards(AdvancementRewards.Builder.recipe(id)).withRequirementsStrategy(IRequirementsStrategy.OR);
}
consumer.accept(getResult(id));
}
protected abstract class RecipeResult implements IFinishedRecipe
{
private final ResourceLocation id;
public RecipeResult(ResourceLocation id)
{
this.id = id;
}
@Override
public JsonObject getRecipeJson()
{
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty(Constants.JSON.TYPE, serializerName.toString());
if (!conditions.isEmpty())
{
JsonArray conditionsArray = new JsonArray();
for (ICondition condition : conditions)
{
conditionsArray.add(CraftingHelper.serialize(condition));
}
jsonObject.add(Constants.JSON.CONDITIONS, conditionsArray);
}
this.serialize(jsonObject);
return jsonObject;
}
@Nonnull
@Override
public IRecipeSerializer<?> getSerializer()
{
// Note: This may be null if something is screwed up but this method isn't
// actually used so it shouldn't matter
// and in fact it will probably be null if only the API is included. But again,
// as we manually just use
// the serializer's name this should not effect us
return ForgeRegistries.RECIPE_SERIALIZERS.getValue(serializerName);
}
@Nonnull
@Override
public ResourceLocation getID()
{
return this.id;
}
@Nullable
@Override
public JsonObject getAdvancementJson()
{
return hasCriteria() ? advancementBuilder.serialize() : null;
}
@Nullable
@Override
public ResourceLocation getAdvancementID()
{
return new ResourceLocation(id.getNamespace(), "recipes/" + id.getPath());
}
}
}

25
src/main/java/wayoftime/bloodmagic/common/data/recipe/BloodMagicRecipeProvider.java Normal file
View file

@ -0,0 +1,25 @@
package wayoftime.bloodmagic.common.data.recipe;
import java.util.Arrays;
import java.util.List;
import net.minecraft.data.DataGenerator;
import wayoftime.bloodmagic.BloodMagic;
import wayoftime.bloodmagic.common.recipe.AlchemyArrayRecipeProvider;
import wayoftime.bloodmagic.common.recipe.BloodAltarRecipeProvider;
import wayoftime.bloodmagic.common.recipe.ISubRecipeProvider;
import wayoftime.bloodmagic.common.recipe.TartaricForgeRecipeProvider;
public class BloodMagicRecipeProvider extends BaseRecipeProvider
{
public BloodMagicRecipeProvider(DataGenerator gen)
{
super(gen, BloodMagic.MODID);
}
@Override
protected List<ISubRecipeProvider> getSubRecipeProviders()
{
return Arrays.asList(new BloodAltarRecipeProvider(), new AlchemyArrayRecipeProvider(), new TartaricForgeRecipeProvider());
}
}

20
src/main/java/wayoftime/bloodmagic/common/data/recipe/RecipeCriterion.java Normal file
View file

@ -0,0 +1,20 @@
package wayoftime.bloodmagic.common.data.recipe;
import net.minecraft.advancements.ICriterionInstance;
public class RecipeCriterion
{
public final String name;
public final ICriterionInstance criterion;
private RecipeCriterion(String name, ICriterionInstance criterion)
{
this.name = name;
this.criterion = criterion;
}
public static RecipeCriterion of(String name, ICriterionInstance criterion)
{
return new RecipeCriterion(name, criterion);
}
}

58
src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/AlchemyArrayRecipeBuilder.java Normal file
View file

@ -0,0 +1,58 @@
package wayoftime.bloodmagic.common.data.recipe.builder;
import javax.annotation.Nonnull;
import com.google.gson.JsonObject;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.Ingredient;
import net.minecraft.util.ResourceLocation;
import wayoftime.bloodmagic.api.SerializerHelper;
import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
import wayoftime.bloodmagic.util.Constants;
public class AlchemyArrayRecipeBuilder extends BloodMagicRecipeBuilder<AlchemyArrayRecipeBuilder>
{
private final ResourceLocation texture;
private final Ingredient baseInput;
private final Ingredient addedInput;
private final ItemStack output;
protected AlchemyArrayRecipeBuilder(ResourceLocation texture, Ingredient baseInput, Ingredient addedInput, ItemStack output)
{
super(bmSerializer("array"));
this.texture = texture;
this.baseInput = baseInput;
this.addedInput = addedInput;
this.output = output;
}
public static AlchemyArrayRecipeBuilder array(ResourceLocation texture, Ingredient baseInput, Ingredient addedInput, ItemStack output)
{
return new AlchemyArrayRecipeBuilder(texture, baseInput, addedInput, output);
}
@Override
protected AlchemyArrayRecipeResult getResult(ResourceLocation id)
{
return new AlchemyArrayRecipeResult(id);
}
public class AlchemyArrayRecipeResult extends RecipeResult
{
protected AlchemyArrayRecipeResult(ResourceLocation id)
{
super(id);
}
@Override
public void serialize(@Nonnull JsonObject json)
{
json.addProperty(Constants.JSON.TEXTURE, texture.toString());
// JSONUtils.getString(json, );
json.add(Constants.JSON.BASEINPUT, baseInput.serialize());
json.add(Constants.JSON.ADDEDINPUT, addedInput.serialize());
json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
}
}
}

63
src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/BloodAltarRecipeBuilder.java Normal file
View file

@ -0,0 +1,63 @@
package wayoftime.bloodmagic.common.data.recipe.builder;
import javax.annotation.Nonnull;
import com.google.gson.JsonObject;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.Ingredient;
import net.minecraft.util.ResourceLocation;
import wayoftime.bloodmagic.api.SerializerHelper;
import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
import wayoftime.bloodmagic.util.Constants;
public class BloodAltarRecipeBuilder extends BloodMagicRecipeBuilder<BloodAltarRecipeBuilder>
{
private final Ingredient input;
private final ItemStack output;
private final int minimumTier;
private final int syphon;
private final int consumeRate;
private final int drainRate;
protected BloodAltarRecipeBuilder(Ingredient input, ItemStack output, int minimumTier, int syphon, int consumeRate, int drainRate)
{
super(bmSerializer("altar"));
this.input = input;
this.output = output;
this.minimumTier = minimumTier;
this.syphon = syphon;
this.consumeRate = consumeRate;
this.drainRate = drainRate;
}
public static BloodAltarRecipeBuilder altar(Ingredient input, ItemStack output, int minimumTier, int syphon, int consumeRate, int drainRate)
{
return new BloodAltarRecipeBuilder(input, output, minimumTier, syphon, consumeRate, drainRate);
}
@Override
protected BloodAltarRecipeResult getResult(ResourceLocation id)
{
return new BloodAltarRecipeResult(id);
}
public class BloodAltarRecipeResult extends RecipeResult
{
protected BloodAltarRecipeResult(ResourceLocation id)
{
super(id);
}
@Override
public void serialize(@Nonnull JsonObject json)
{
json.add(Constants.JSON.INPUT, input.serialize());
json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
json.addProperty(Constants.JSON.ALTAR_TIER, minimumTier);
json.addProperty(Constants.JSON.ALTAR_SYPHON, syphon);
json.addProperty(Constants.JSON.ALTAR_CONSUMPTION_RATE, consumeRate);
json.addProperty(Constants.JSON.ALTAR_DRAIN_RATE, drainRate);
}
}
}

75
src/main/java/wayoftime/bloodmagic/common/data/recipe/builder/TartaricForgeRecipeBuilder.java Normal file
View file

@ -0,0 +1,75 @@
package wayoftime.bloodmagic.common.data.recipe.builder;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nonnull;
import com.google.gson.JsonObject;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.Ingredient;
import net.minecraft.util.ResourceLocation;
import wayoftime.bloodmagic.api.SerializerHelper;
import wayoftime.bloodmagic.common.data.recipe.BloodMagicRecipeBuilder;
import wayoftime.bloodmagic.util.Constants;
public class TartaricForgeRecipeBuilder extends BloodMagicRecipeBuilder<TartaricForgeRecipeBuilder>
{
private final List<Ingredient> input;
private final ItemStack output;
private final double minimumSouls;
private final double soulDrain;
protected TartaricForgeRecipeBuilder(List<Ingredient> input, ItemStack output, double minimumSouls, double soulDrain)
{
super(bmSerializer("soulforge"));
this.input = input;
this.output = output;
this.minimumSouls = minimumSouls;
this.soulDrain = soulDrain;
}
public static TartaricForgeRecipeBuilder tartaricForge(List<Ingredient> input, ItemStack output, double minimumSouls, double soulDrain)
{
return new TartaricForgeRecipeBuilder(input, output, minimumSouls, soulDrain);
}
public static TartaricForgeRecipeBuilder tartaricForge(ItemStack output, double minimumSouls, double soulDrain, Ingredient... inputArray)
{
List<Ingredient> inputList = new ArrayList<Ingredient>();
for (int i = 0; i < inputArray.length; i++)
{
inputList.add(inputArray[i]);
}
return new TartaricForgeRecipeBuilder(inputList, output, minimumSouls, soulDrain);
}
@Override
protected TartaricForgeRecipeResult getResult(ResourceLocation id)
{
return new TartaricForgeRecipeResult(id);
}
public class TartaricForgeRecipeResult extends RecipeResult
{
protected TartaricForgeRecipeResult(ResourceLocation id)
{
super(id);
}
@Override
public void serialize(@Nonnull JsonObject json)
{
for (int i = 0; i < Math.min(input.size(), 4); i++)
{
json.add(Constants.JSON.INPUT + i, input.get(i).serialize());
}
json.add(Constants.JSON.OUTPUT, SerializerHelper.serializeItemStack(output));
json.addProperty(Constants.JSON.TARTARIC_MINIMUM, (float) minimumSouls);
json.addProperty(Constants.JSON.TARTARIC_DRAIN, (float) soulDrain);
}
}
}