Minecraft Forums

CrypticBat has a custom modpack created on Technic called The CrypticBat Pack

CrypticBat is running 103 mods and has a little bit of everything Machines, Magic, and Space

Modpack - https://www.technicpack.net/modpack/crypticbat-pack.1234204
Discord - https://discord.gg/zdbjrFb

Hello everyone, I am always working on trying to make CrypticBat more enjoyable for everyone
so any mod/server suggestions that you might have feel free to share your ideas in discord

.

Quote from ceoepts

Start out by publishing a block

public static final BlockCustomDoor customDoor = new BlockCustomDoor(3000).setHardness(1.0F).setUnlocalizedName("customdoor");

then register the block in the load method

GameRegistry.registerBlock(customDoor);

now create the block file (BlockCustomDoor.class) and copy the code from the BlockDoor file

package net.minecraft.block;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.IconFlipped;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.Icon;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.util.Vec3;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockDoor extends Block
{
private static final String[] doorIconNames = new String[] {"doorWood_lower", "doorWood_upper", "doorIron_lower", "doorIron_upper"};
/** Used for pointing at icon names. */
private final int doorTypeForIcon;
@SideOnly(Side.CLIENT)
private Icon[] iconArray;
protected BlockDoor(int par1, Material par2Material)
{
	 super(par1, par2Material);
	 if (par2Material == Material.iron)
	 {
		 this.doorTypeForIcon = 2;
	 }
	 else
	 {
		 this.doorTypeForIcon = 0;
	 }
	 float f = 0.5F;
	 float f1 = 1.0F;
	 this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, f1, 0.5F + f);
}
@SideOnly(Side.CLIENT)
/**
	 * From the specified side and block metadata retrieves the blocks texture. Args: side, metadata
	 */
public Icon getIcon(int par1, int par2)
{
	 return this.iconArray[this.doorTypeForIcon];
}
@SideOnly(Side.CLIENT)
/**
	 * Retrieves the block texture to use based on the display side. Args: iBlockAccess, x, y, z, side
	 */
public Icon getBlockTexture(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
	 if (par5 != 1 && par5 != 0)
	 {
		 int i1 = this.getFullMetadata(par1IBlockAccess, par2, par3, par4);
		 int j1 = i1 & 3;
		 boolean flag = (i1 & 4) != 0;
		 boolean flag1 = false;
		 boolean flag2 = (i1 & 8) != 0;
		 if (flag)
		 {
			 if (j1 == 0 && par5 == 2)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 1 && par5 == 5)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 2 && par5 == 3)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 3 && par5 == 4)
			 {
				 flag1 = !flag1;
			 }
		 }
		 else
		 {
			 if (j1 == 0 && par5 == 5)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 1 && par5 == 3)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 2 && par5 == 4)
			 {
				 flag1 = !flag1;
			 }
			 else if (j1 == 3 && par5 == 2)
			 {
				 flag1 = !flag1;
			 }
			 if ((i1 & 16) != 0)
			 {
				 flag1 = !flag1;
			 }
		 }
		 return this.iconArray[this.doorTypeForIcon + (flag1 ? doorIconNames.length : 0) + (flag2 ? 1 : 0)];
	 }
	 else
	 {
		 return this.iconArray[this.doorTypeForIcon];
	 }
}
@SideOnly(Side.CLIENT)
/**
	 * When this method is called, your block should register all the icons it needs with the given IconRegister. This
	 * is the only chance you get to register icons.
	 */
public void registerIcons(IconRegister par1IconRegister)
{
	 this.iconArray = new Icon[doorIconNames.length * 2];
	 for (int i = 0; i < doorIconNames.length; ++i)
	 {
		 this.iconArray[i] = par1IconRegister.registerIcon(doorIconNames[i]);
		 this.iconArray[i + doorIconNames.length] = new IconFlipped(this.iconArray[i], true, false);
	 }
}
/**
	 * Is this block (a) opaque and (B) a full 1m cube? This determines whether or not to render the shared face of two
	 * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
	 */
public boolean isOpaqueCube()
{
	 return false;
}
public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
	 int l = this.getFullMetadata(par1IBlockAccess, par2, par3, par4);
	 return (l & 4) != 0;
}
/**
	 * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
	 */
public boolean renderAsNormalBlock()
{
	 return false;
}
/**
	 * The type of render function that is called for this block
	 */
public int getRenderType()
{
	 return 7;
}
@SideOnly(Side.CLIENT)
/**
	 * Returns the bounding box of the wired rectangular prism to render.
	 */
public AxisAlignedBB getSelectedBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
	 this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
	 return super.getSelectedBoundingBoxFromPool(par1World, par2, par3, par4);
}
/**
	 * Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
	 * cleared to be reused)
	 */
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
	 this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
	 return super.getCollisionBoundingBoxFromPool(par1World, par2, par3, par4);
}
/**
	 * Updates the blocks bounds based on its current state. Args: world, x, y, z
	 */
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
	 this.setDoorRotation(this.getFullMetadata(par1IBlockAccess, par2, par3, par4));
}
/**
	 * Returns 0, 1, 2 or 3 depending on where the hinge is.
	 */
public int getDoorOrientation(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
	 return this.getFullMetadata(par1IBlockAccess, par2, par3, par4) & 3;
}
public boolean isDoorOpen(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
	 return (this.getFullMetadata(par1IBlockAccess, par2, par3, par4) & 4) != 0;
}
private void setDoorRotation(int par1)
{
	 float f = 0.1875F;
	 this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.0F, 1.0F);
	 int j = par1 & 3;
	 boolean flag = (par1 & 4) != 0;
	 boolean flag1 = (par1 & 16) != 0;
	 if (j == 0)
	 {
		 if (flag)
		 {
			 if (!flag1)
			 {
				 this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, f);
			 }
			 else
			 {
				 this.setBlockBounds(0.0F, 0.0F, 1.0F - f, 1.0F, 1.0F, 1.0F);
			 }
		 }
		 else
		 {
			 this.setBlockBounds(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F);
		 }
	 }
	 else if (j == 1)
	 {
		 if (flag)
		 {
			 if (!flag1)
			 {
				 this.setBlockBounds(1.0F - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
			 }
			 else
			 {
				 this.setBlockBounds(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F);
			 }
		 }
		 else
		 {
			 this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, f);
		 }
	 }
	 else if (j == 2)
	 {
		 if (flag)
		 {
			 if (!flag1)
			 {
				 this.setBlockBounds(0.0F, 0.0F, 1.0F - f, 1.0F, 1.0F, 1.0F);
			 }
			 else
			 {
				 this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, f);
			 }
		 }
		 else
		 {
			 this.setBlockBounds(1.0F - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
		 }
	 }
	 else if (j == 3)
	 {
		 if (flag)
		 {
			 if (!flag1)
			 {
				 this.setBlockBounds(0.0F, 0.0F, 0.0F, f, 1.0F, 1.0F);
			 }
			 else
			 {
				 this.setBlockBounds(1.0F - f, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
			 }
		 }
		 else
		 {
			 this.setBlockBounds(0.0F, 0.0F, 1.0F - f, 1.0F, 1.0F, 1.0F);
		 }
	 }
}
/**
	 * Called when the block is clicked by a player. Args: x, y, z, entityPlayer
	 */
public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer) {}
/**
	 * Called upon block activation (right click on the block.)
	 */
public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
{
	 if (this.blockMaterial == Material.iron)
	 {
		 return false; //Allow items to interact with the door
	 }
	 else
	 {
		 int i1 = this.getFullMetadata(par1World, par2, par3, par4);
		 int j1 = i1 & 7;
		 j1 ^= 4;
		 if ((i1 & 8) == 0)
		 {
			 par1World.setBlockMetadataWithNotify(par2, par3, par4, j1, 2);
			 par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
		 }
		 else
		 {
			 par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, j1, 2);
			 par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
		 }
		 par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
		 return true;
	 }
}
/**
	 * A function to open a door.
	 */
public void onPoweredBlockChange(World par1World, int par2, int par3, int par4, boolean par5)
{
	 int l = this.getFullMetadata(par1World, par2, par3, par4);
	 boolean flag1 = (l & 4) != 0;
	 if (flag1 != par5)
	 {
		 int i1 = l & 7;
		 i1 ^= 4;
		 if ((l & 8) == 0)
		 {
			 par1World.setBlockMetadataWithNotify(par2, par3, par4, i1, 2);
			 par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
		 }
		 else
		 {
			 par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, i1, 2);
			 par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
		 }
		 par1World.playAuxSFXAtEntity((EntityPlayer)null, 1003, par2, par3, par4, 0);
	 }
}
/**
	 * Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
	 * their own) Args: x, y, z, neighbor blockID
	 */
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
{
	 int i1 = par1World.getBlockMetadata(par2, par3, par4);
	 if ((i1 & 8) == 0)
	 {
		 boolean flag = false;
		 if (par1World.getBlockId(par2, par3 + 1, par4) != this.blockID)
		 {
			 par1World.setBlockToAir(par2, par3, par4);
			 flag = true;
		 }
		 if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4))
		 {
			 par1World.setBlockToAir(par2, par3, par4);
			 flag = true;
			 if (par1World.getBlockId(par2, par3 + 1, par4) == this.blockID)
			 {
				 par1World.setBlockToAir(par2, par3 + 1, par4);
			 }
		 }
		 if (flag)
		 {
			 if (!par1World.isRemote)
			 {
				 this.dropBlockAsItem(par1World, par2, par3, par4, i1, 0);
			 }
		 }
		 else
		 {
			 boolean flag1 = par1World.isBlockIndirectlyGettingPowered(par2, par3, par4) || par1World.isBlockIndirectlyGettingPowered(par2, par3 + 1, par4);
			 if ((flag1 || par5 > 0 && Block.blocksList[par5].canProvidePower()) && par5 != this.blockID)
			 {
				 this.onPoweredBlockChange(par1World, par2, par3, par4, flag1);
			 }
		 }
	 }
	 else
	 {
		 if (par1World.getBlockId(par2, par3 - 1, par4) != this.blockID)
		 {
			 par1World.setBlockToAir(par2, par3, par4);
		 }
		 if (par5 > 0 && par5 != this.blockID)
		 {
			 this.onNeighborBlockChange(par1World, par2, par3 - 1, par4, par5);
		 }
	 }
}
/**
	 * Returns the ID of the items to drop on destruction.
	 */
public int idDropped(int par1, Random par2Random, int par3)
{
	 return (par1 & 8) != 0 ? 0 : (this.blockMaterial == Material.iron ? Item.doorIron.itemID : Item.doorWood.itemID);
}
/**
	 * Ray traces through the blocks collision from start vector to end vector returning a ray trace hit. Args: world,
	 * x, y, z, startVec, endVec
	 */
public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3 par5Vec3, Vec3 par6Vec3)
{
	 this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
	 return super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3, par6Vec3);
}
/**
	 * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
	 */
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
	 return par3 >= 255 ? false : par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && super.canPlaceBlockAt(par1World, par2, par3, par4) && super.canPlaceBlockAt(par1World, par2, par3 + 1, par4);
}
/**
	 * Returns the mobility information of the block, 0 = free, 1 = can't push but can move over, 2 = total immobility
	 * and stop pistons
	 */
public int getMobilityFlag()
{
	 return 1;
}
/**
	 * Returns the full metadata value created by combining the metadata of both blocks the door takes up.
	 */
public int getFullMetadata(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
	 int l = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
	 boolean flag = (l & 8) != 0;
	 int i1;
	 int j1;
	 if (flag)
	 {
		 i1 = par1IBlockAccess.getBlockMetadata(par2, par3 - 1, par4);
		 j1 = l;
	 }
	 else
	 {
		 i1 = l;
		 j1 = par1IBlockAccess.getBlockMetadata(par2, par3 + 1, par4);
	 }
	 boolean flag1 = (j1 & 1) != 0;
	 return i1 & 7 | (flag ? 8 : 0) | (flag1 ? 16 : 0);
}
@SideOnly(Side.CLIENT)
/**
	 * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
	 */
public int idPicked(World par1World, int par2, int par3, int par4)
{
	 return this.blockMaterial == Material.iron ? Item.doorIron.itemID : Item.doorWood.itemID;
}
/**
	 * Called when the block is attempted to be harvested
	 */
public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5, EntityPlayer par6EntityPlayer)
{
	 if (par6EntityPlayer.capabilities.isCreativeMode && (par5 & 8) != 0 && par1World.getBlockId(par2, par3 - 1, par4) == this.blockID)
	 {
		 par1World.setBlockToAir(par2, par3 - 1, par4);
	 }
}
}

And change the code until it fitts your mod

Quote from ProLeopard

Steven is there anyway you can also show us how to make ores only generate in certain places (such as only under water)?

Quote from sorash67

*** TIP ***
search for your request before posting a thread for it! There are MANY tutorials on most of the requests you have! Please search it up and im sure you find very good stuff!

-sorash67 || Skorpio