Files
MinecraftForge/src/test/java/net/minecraftforge/debug/FluidPlacementTest.java
T
LexManos be80bc5e4c First pass of registry rewrite.
Tests do not run yet.
Things of note:
Removed the idea of substitutions, just register multiple items with the same name they will override each other like a normal map.
Decoupled Forge registries from vanilla classes. They now use bouncer classes. MODDERS SHOULD NEVER USE THESE
Introduced more stringent registry locking. As it sits things are only allowed to be registered during the RegistryEvent.Registry phases!
This is to force modders to split up their registrations, and pave the way for calling these functions multiple times during a single MC lifecycle.
ObjectHolder, Missing Mappings, etc... *should* now work for all registry types, nothing should be special cased to Blocks/Items anymore.
Added optional generic dummy factory to registries, to allow registry creators the ability to dummy more then just Blocks.
Re-worked the ItemStack transformer and applied it to ItemBlock and ItemBlockSpecial. Allowing us to cleanup reflective hacks in Block callbacks.
Registry onAdd callback is now only fired on the ACTIVE registry, fixing any issues of temp registries overriding active objects.
2017-06-23 11:04:13 -07:00

296 lines
11 KiB
Java

package net.minecraftforge.debug;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.renderer.ItemMeshDefinition;
import net.minecraft.client.renderer.block.model.ModelBakery;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.client.renderer.block.statemap.StateMapperBase;
import net.minecraft.client.util.ITooltipFlag;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemBucket;
import net.minecraft.item.ItemBucketMilk;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.NonNullList;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraftforge.client.model.ModelLoader;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.fluids.BlockFluidFinite;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.UniversalBucket;
import net.minecraftforge.fluids.capability.templates.FluidHandlerItemStack;
import net.minecraftforge.fluids.capability.wrappers.FluidBucketWrapper;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.SidedProxy;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import static net.minecraftforge.fluids.capability.templates.FluidHandlerItemStack.FLUID_NBT_KEY;
@Mod(modid = FluidPlacementTest.MODID, name = "ForgeDebugFluidPlacement", version = FluidPlacementTest.VERSION, acceptableRemoteVersions = "*")
public class FluidPlacementTest
{
public static final String MODID = "forgedebugfluidplacement";
public static final String VERSION = "1.0";
public static final boolean ENABLE = true;
@SidedProxy
public static CommonProxy proxy;
@EventHandler
public void preInit(FMLPreInitializationEvent event)
{
if (!ENABLE || !ModelFluidDebug.ENABLE)
return;
proxy.preInit();
}
@Mod.EventBusSubscriber(modid = MODID)
public static class Registration
{
@SubscribeEvent
public static void registrBlocks(RegistryEvent.Register<Block> event)
{
if (!ENABLE || !ModelFluidDebug.ENABLE)
return;
event.getRegistry().registerAll(
FiniteFluidBlock.instance
);
}
@SubscribeEvent
public static void registrItems(RegistryEvent.Register<Item> event)
{
if (!ENABLE || !ModelFluidDebug.ENABLE)
return;
FluidRegistry.registerFluid(FiniteFluid.instance);
FluidRegistry.addBucketForFluid(FiniteFluid.instance);
event.getRegistry().registerAll(
EmptyFluidContainer.instance,
FluidContainer.instance,
new ItemBlock(FiniteFluidBlock.instance).setRegistryName(FiniteFluidBlock.instance.getRegistryName())
);
MinecraftForge.EVENT_BUS.register(FluidContainer.instance);
}
}
public static class CommonProxy {
public void preInit(){}
}
public static class ServerProxy extends CommonProxy{}
public static class ClientProxy extends CommonProxy
{
private static ModelResourceLocation fluidLocation = new ModelResourceLocation(MODID.toLowerCase() + ":" + FiniteFluidBlock.name, "normal");
@Override
public void preInit()
{
Item fluid = Item.getItemFromBlock(FiniteFluidBlock.instance);
ModelLoader.setCustomModelResourceLocation(EmptyFluidContainer.instance, 0, new ModelResourceLocation("forge:bucket", "inventory"));
ModelLoader.setBucketModelDefinition(FluidContainer.instance);
// no need to pass the locations here, since they'll be loaded by the block model logic.
ModelBakery.registerItemVariants(fluid);
ModelLoader.setCustomMeshDefinition(fluid, stack -> fluidLocation);
ModelLoader.setCustomStateMapper(FiniteFluidBlock.instance, new StateMapperBase()
{
@Override
protected ModelResourceLocation getModelResourceLocation(IBlockState state)
{
return fluidLocation;
}
});
}
}
public static final class FiniteFluid extends Fluid
{
public static final String name = "finitefluid";
public static final FiniteFluid instance = new FiniteFluid();
private FiniteFluid()
{
super(name, new ResourceLocation("blocks/water_still"), new ResourceLocation("blocks/water_flow"));
}
@Override
public int getColor()
{
return 0xFFFFFF00;
}
@Override
public String getLocalizedName(FluidStack stack)
{
return "Finite Fluid";
}
}
public static final class FiniteFluidBlock extends BlockFluidFinite
{
public static final FiniteFluidBlock instance = new FiniteFluidBlock();
public static final String name = "finite_fluid_block";
private FiniteFluidBlock()
{
super(FiniteFluid.instance, Material.WATER);
setCreativeTab(CreativeTabs.BUILDING_BLOCKS);
setUnlocalizedName(MODID + ":" + name);
setRegistryName(MODID, name);
}
}
public static final class EmptyFluidContainer extends ItemBucket
{
public static final EmptyFluidContainer instance = new EmptyFluidContainer();
public static final String name = "empty_fluid_container";
private EmptyFluidContainer()
{
super(Blocks.AIR);
setRegistryName(MODID, name);
setUnlocalizedName(MODID + ":" + name);
setMaxStackSize(16);
}
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt)
{
return new EmptyContainerHandler(stack);
}
private static final class EmptyContainerHandler extends FluidBucketWrapper
{
public EmptyContainerHandler(@Nonnull ItemStack container)
{
super(container);
}
@Override
public int fill(FluidStack resource, boolean doFill)
{
if (container.getCount() != 1 || resource == null || resource.amount > Fluid.BUCKET_VOLUME || container
.getItem() instanceof ItemBucketMilk || getFluid() != null || !canFillFluidType(resource))
{
return 0;
}
if (doFill)
{
container = new ItemStack(FluidContainer.instance);
NBTTagCompound tag = new NBTTagCompound();
NBTTagCompound fluidTag = new NBTTagCompound();
resource.writeToNBT(fluidTag);
tag.setTag(FLUID_NBT_KEY, fluidTag);
container.setTagCompound(tag);
}
return resource.amount;
}
}
}
public static final class FluidContainer extends UniversalBucket
{
public static final FluidContainer instance = new FluidContainer();
public static final String name = "fluid_container";
private FluidContainer()
{
super(1000, new ItemStack(EmptyFluidContainer.instance), false);
setCreativeTab(CreativeTabs.MISC);
setRegistryName(MODID, name);
setUnlocalizedName(MODID + ":" + name);
}
@Nonnull
@Override
public String getItemStackDisplayName(@Nonnull ItemStack stack)
{
FluidStack fluid = getFluid(stack);
if (fluid == null || fluid.getFluid() == null)
{
return "Empty Variable Container";
}
return "Variable Container (" + getFluid(stack).getLocalizedName() + ")";
}
@Override
@Nullable
public FluidStack getFluid(ItemStack container)
{
container = container.copy();
if (container.getTagCompound() != null)
{
container.setTagCompound(container.getTagCompound().getCompoundTag(FLUID_NBT_KEY));
}
return super.getFluid(container);
}
@Override
@SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, @Nullable World playerIn, List<String> tooltip, ITooltipFlag advanced)
{
FluidStack fluid = getFluid(stack);
if (fluid != null)
{
tooltip.add(fluid.amount + "/1000");
}
}
@Override
public void getSubItems(@Nullable CreativeTabs tab, @Nonnull NonNullList<ItemStack> subItems)
{
if (!this.isInCreativeTab(tab))
return;
Fluid[] fluids = new Fluid[]{FluidRegistry.WATER, FluidRegistry.LAVA, FiniteFluid.instance, ModelFluidDebug.FLUID};
// add 16 variable fillings
for (Fluid fluid : fluids)
{
for (int amount = 125; amount <= 1000; amount += 125)
{
for (int offset = 63; offset >= 0; offset -= 63)
{
FluidStack fs = new FluidStack(fluid, amount - offset);
ItemStack stack = new ItemStack(this);
NBTTagCompound tag = stack.getTagCompound();
if (tag == null)
{
tag = new NBTTagCompound();
}
NBTTagCompound fluidTag = new NBTTagCompound();
fs.writeToNBT(fluidTag);
tag.setTag(FLUID_NBT_KEY, fluidTag);
stack.setTagCompound(tag);
subItems.add(stack);
}
}
}
}
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, NBTTagCompound nbt)
{
return new FluidHandlerItemStack.SwapEmpty(stack, new ItemStack(EmptyFluidContainer.instance), 1000);
}
}
}