[长期更新]1.12Forge mod开发教程

ItemStack iron=new ItemStack（metal，1,1）；
ItemStack copper=new ItemStack（metal，1,2）；
通过上述三行，你已经声明了同一个Item的两个ItemStack，会在游戏中被玩家看到。
ItemStack有7个构造器，说明了声明一个ItemStack需要的参数：

1. public ItemStack(Block blockIn){/*通过一个方块blockIn声明相应的物品，例如半砖方块获取半砖物品*/}
   
2.     public ItemStack(Block blockIn, int amount){/*你可以再指定物品堆叠数量，由于我们在创造物品栏看到的物品都是一个一个的，因此amount一般设为1*/}
   
3.     public ItemStack(Block blockIn, int amount, int meta){/*meta是标签，可以是1,2,3……等int数，无论你声明多少个meta，都只消耗一个id}
   
4.     public ItemStack(Item itemIn){/*通过一个物品itemIn声明相应的物品实例，例如new ItemStack（Items.DIAMOND）*/}
   
5.     public ItemStack(Item itemIn, int amount){/*你可以再指定物品堆叠数量，由于我们在创造物品栏看到的物品都是一个一个的，因此amount一般设为1*/}
   
6.     public ItemStack(Item itemIn, int amount, int meta){/*meta作用同上，起到一个标签的作用，这样无论你声明多少个物品实例，都只消耗一个物品ID*/}
   
7.     public ItemStack(Item itemIn, int amount, int meta, @Nullable NBTTagCompound capNBT){
   
8. /*为物品添加附加的NBT，例如物品一合成出来就有时运3附魔*/
   
9. /*例子：
   
10. NBTTagCompound nbtTagCompound=new NBTTagCompound（）；
    
11. nbtTagCompound.setInteger（“id”，Enchantment.getEnchantmentID（Enchantments.FORTUNE））；
    
12. nbtTagCompound.setInteger（“lvl”，3）；
    
13. //不用怀疑，NBT就是这样的刻意声明，“lvl”一定代表附魔等级，自己声明NBT标签的时候注意一下
    
14. ……
    
15. new ItemStack（yourItem，1,1，nbtTagCompound）；*/
    
16. }
    
17. public ItemStack(NBTTagCompound compound){}

复制代码

你可以用ItemStack.getItem（）或者Item.getDefaultInstance（）来实现Item和ItemStack的互转。注意，getDefaultInstance（）可能会引发异常，而且无法根据用户要求返回一个具体的ItemStack，例如mekanism有4个等级的输导矩阵，在calculator（运算工艺）的原子增幅仪里复制就只能得到普通的输导矩阵，因为得到的ItemStack中，并没有指定具体的metadata，而只是getDefaultInstance（）。
public ItemStack splitStack(int amount){}
//按照给定的数量，将ItemStack分成两堆

public EnumActionResult onItemUse(EntityPlayer playerIn, World worldIn, BlockPos pos, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ){
//当把玩家手中的物品（不管哪只手）右键方块使用时，进行的操作，例如剪刀右键树叶
/*if（worldIn.provider.getDimension（）=6）//6是aroma1997矿界的id，当然可能会被修改
switch（side）{
case（side==EnumFacing.SOUTH):spawnEntity(……);//如果是南面，召唤一个实体，随便什么都行
}*/
}

public EnumActionResult onItemUseFirst(EntityPlayer playerIn, World worldIn, BlockPos pos, EnumHand hand, EnumFacing side, float hitX, float hitY, float hitZ){}
//与onItemUse（）几乎一样，具体区别可查看Item.onItemUseFirst（）

public float getDestroySpeed(IBlockState blockIn){}
//获取物品对方块的破坏速度，因为一把镐对钻石和黑曜石的破坏速度肯定不一样

//没什么可说的，这两个方法都是直接调取对应Item的方法，本质完全一样
public ActionResult<ItemStack> useItemRightClick(World worldIn, EntityPlayer playerIn, EnumHand hand)
{
    return this.getItem().onItemRightClick(worldIn, playerIn, hand);
}

public ItemStack onItemUseFinish(World worldIn, EntityLivingBase entityLiving)
{
    return this.getItem().onItemUseFinish(this, worldIn, entityLiving);
}

public NBTTagCompound writeToNBT(NBTTagCompound nbt){}
//将一段NBT写入当前ItemStack中，完成玩家所希望的属性的持久化存储

//没什么可说的都一样
public int getMaxStackSize()
{
    return this.getItem().getItemStackLimit(this);
}
public boolean isItemStackDamageable(){}
//判断一个物品是否有耐久，如果没有，它会有一个boolean类型的标签“Unbreakable”


public boolean isItemDamaged(){}
//判断物品是不是满耐久，返回true则代表已经受损，或者不是满能量


public boolean attemptDamageItem(int amount, Random rand, @Nullable EntityPlayerMP damager){}
//尝试破坏玩家手中的物品，如果该物品有耐久附魔，将会有几率取消耐久损耗，如果带来的耐久损耗（amount）大于最大耐久，物品则被破坏，该方法返回true

public boolean attemptDamageItem(int amount, Random rand, @Nullable EntityPlayerMP damager){}
损耗给定的耐久值，如果amount大于当前耐久值，物品会被直接破坏

public void hitEntity(EntityLivingBase entityIn, EntityPlayer playerIn){}
//打击实体，没什么可说的

public void onBlockDestroyed(World worldIn, IBlockState blockIn, BlockPos pos, EntityPlayer playerIn){
//在方块被破坏时做些什么
/*if(blockIn.getBlock().equals(Blocks.OBSIDIAN && playerIn.getHealth()<5)
spawnEntity(ENTITY_LIGHTNING_THUNDER);
//如果玩家在血量低于5的情况下挖黑曜石，当黑曜石被破坏时劈下闪电*/
}

public ItemStack copy(){}
//复制一个一样的ItemStack


public static boolean areItemStackTagsEqual(ItemStack stackA, ItemStack stackB){}
//判断两个ItemStack的NBT是否一致

public static boolean areItemStacksEqual(ItemStack stackA, ItemStack stackB){}
//比较两个ItemStack是否完全一致

public static boolean areItemsEqual(ItemStack stackA, ItemStack stackB)
//只比较两个ItemStack的物品和耐久值，忽略NBT

public static boolean areItemsEqualIgnoreDurability(ItemStack stackA, ItemStack stackB){}
//只比较两个ItemStack是否物品相同，忽略耐久

public String getUnlocalizedName(){}
//获得ItemStack的未本地化名

public void updateAnimation(World worldIn, Entity entityIn, int inventorySlot, boolean isCurrentItem){}
//更新动画，一般用于地图的更新

public void onCrafting(World worldIn, EntityPlayer playerIn, int amount)
{
    //无可奉告，参考Item.onCreated（）
    playerIn.addStat(StatList.getCraftStats(this.item), amount);
    this.getItem().onCreated(this, worldIn, playerIn);
}

public boolean hasTagCompound(){}
//判断该ItemStack是否有NBT

public NBTTagCompound getTagCompound(){}
//获取NBT

public NBTTagCompound getOrCreateSubCompound(String key){}
//获取（如果没有则创建）一个子NBT

public void removeSubCompound(String key){}
//移除子NBT

public NBTTagList getEnchantmentTagList(){}
//根据“ench”这个key，获得该ItemStack的NBTList

public void setTagCompound(@Nullable NBTTagCompound nbt){}
//把一个NBT分配到这个ItemStack

public ItemStack setTranslatableName(String p_190924_1_){}
//在NBT里设置一个可以翻译的名字

public List<String> getTooltip(@Nullable EntityPlayer playerIn, ITooltipFlag advanced){}
//获取这个物品的tooltip，例如你为心爱姑娘在工具里写的情诗

public void addEnchantment(Enchantment ench, int level){}
//为ItemStack添加附魔，Enchantment是附魔，level是附魔等级
//Enchantment ench=ForgeRegistries.ENCHANTMENTS.getValue("Unbreaking");
//addEnchantment(ench,3);

public void setTagInfo(String key, NBTBase value)
{
    //和setTag唯一的区别在于无需用户手动判断null
    if (this.stackTagCompound == null)
    {
        this.setTagCompound(new NBTTagCompound());
    }
    this.stackTagCompound.setTag(key, value);
}

public boolean isOnItemFrame(){}
//这个物品在不在物品展示框里面

//显而易见
public void setItemFrame(EntityItemFrame frame)
{
    this.itemFrame = frame;
}

@Nullable
public EntityItemFrame getItemFrame()
{
    return this.isEmpty ? null : this.itemFrame;
}

public int getRepairCost(){}
//获取这个ItemStack的铁砧修理费

public void setRepairCost(int cost){}
//设置这个ItemStack的铁砧修理费

public Multimap<String, AttributeModifier> getAttributeModifiers(EntityEquipmentSlot equipmentSlot){
//……
//AttributeModifier attributemodifier = SharedMonsterAttributes.readAttributeModifierFromNBT(nbttagcompound);
//……
//与Item.getAtrributeModifiers不同，ItemStack.getAttributeModifiers会检查ItemStack的NBT以找到需要的属性
}

public void addAttributeModifier(String attributeName, AttributeModifier modifier, @Nullable EntityEquipmentSlot equipmentSlot){}
//直接给工具添加属性，modifier用作实参时可以用SharedMonsterAtrributes.readAttributeModifierFromNBT(NBTTagCompound compound)来从NBT获取

public boolean canDestroy(Block blockIn){}
//是否能破坏指定方块blockIn

public boolean canPlaceOn(Block blockIn){}
//Itemstack能够放在方块上，一般这样的方块只有物品展示框

public int getCount(){}
//获取ItemStack里物品的数量，例如一堆物品有35个，那得到的数量就是35

public void setCount(int size){}
//指定ItemStack中物品的数量

public void grow(int quantity){}
//让ItemStack中的物品数量增长一定数量（quantity）

public void shrink(int quantity){}
//让ItemStack中的物品减少一定数量，例如丢鸡蛋时，就需要shrink(1)


public boolean hasCapability(net.minecraftforge.common.capabilities.Capability<?> capability, @Nullable net.minecraft.util.EnumFacing facing){}
//该物品是否具有能力（capability），如果不注重facing可以为null

@Override
@Nullable
public <T> T getCapability(net.minecraftforge.common.capabilities.Capability<T> capability, @Nullable net.minecraft.util.EnumFacing facing){}
//获取相应的能力，facing一般情况下null就可以

//与readNBT和writeNBT大同小异
public void deserializeNBT(NBTTagCompound nbt)
{
    // TODO do this better while respecting new rules
final ItemStack itemStack = new ItemStack(nbt);
    this.stackTagCompound = itemStack.stackTagCompound;
    this.capNBT = itemStack.capNBT;
}

public NBTTagCompound serializeNBT()
{
    NBTTagCompound ret = new NBTTagCompound();
    this.writeToNBT(ret);
    return ret;
}

public static boolean areItemStacksEqualUsingNBTShareTag(ItemStack stackA, ItemStack stackB){}
//基于areItemStackShareTagsEqual(ItemStack stackA, ItemStack stackB)方法，比较两个ItemStack所对应的Item的NBT


有必要说清楚的一件事是，在MC里并不是真的画了10万个草方块，而是把同一个草方块画了10万遍（如果你学习OpenGL，可以了解一下实例化渲染），符合Java的“享元模式”，因此也有人说MC的方块（Block）是享元的，如果是熔炉这样，存在内容物且内容物不定，那么就不能是享元的——否则你会看到100个里面有一组生鸡肉且一起被烧熟的熔炉，这样的东西往往用TileEntity描述。
public static int getIdFromBlock(Block blockIn)
{
    return REGISTRY.getIDForObject(blockIn);
    //由方块blockIn获取一个方块的id
    //不难看出，在forge环境下，我们经常使用REGISTRY来获取各种物品，方块等，而不是原版本身声明的方式
    //public static final RegistryNamespacedDefaultedByKey<ResourceLocation, Block> REGISTRY = net.minecraftforge.registries.GameData.getWrapperDefaulted(Block.class);
}

public static int getStateId(IBlockState state){}
//由给定的IBlockState获取state的id，在MC中Block和IBlockState是密不可分的

public static Block getBlockById(int id){}
//和getIdFromBlock反过来，由id获取方块，但是非原版情况下似乎没人知道哪个id对应哪个方块

public static IBlockState getStateById(int id){}
//和getStateId反过来，由id获取IBlockState

public static Block getBlockFromItem(@Nullable Item itemIn){}
//如果Item是ItemBlock的话，就可以从这个Item获取相应的Block

public static Block getBlockFromName(String name){}
//由名称例如“Obsidian”获取相应方块

public int getMetaFromState(IBlockState state){}
//由传入的IBlockState获取相应的meta值，适合一个方块有多种meta的情况，例如末地门框架

public Block setLightOpacity(int opacity){}
//一般用在方块构造函数内部，指定方块的不透明度

public Block setLightLevel(float value){}
//一般用在方块构造函数内部，指定方块的亮度，value介于0-1之间（乘15为实际值），也可以取更大的数

public Block setResistance(float resistance){}
//一般用在方块构造函数内部，指定方块的抗爆性，resistance一般为10（乘3为实际值），也可以取别的数

public Block setHardness(float hardness){}
//一般用在方块构造函数内部，指定方块的硬度，hardness一般为6（乘5为实际值），也可以取别的数

public Block setBlockUnbreakable(){}
//一般用在方块构造函数内部，直接将方块设为不可破坏

public Block setTickRandomly(boolean shouldTick){}
//一般用在方块构造函数内部，如果shouldTick为true，方块将随机时间更新

protected static boolean isExceptionBlockForAttaching(Block attachBlock)
{
    return true；
    //if(Block.isExceptionForAttaching(attachBlock)
    //用来判断或指定不能直接左键破坏或者破坏后会丢失内容物的方块，
    //默认有潜影箱，树叶，活板门，信标，炼药锅，玻璃，萤石块，冰，海晶灯
}
public boolean isPassable(IBlockAccess worldIn, BlockPos pos)
{
    return true;
    //用来判断或指定可以直接通过的方块，例如草
}
public boolean isReplaceable(IBlockAccess worldIn, BlockPos pos){return false；}
//用来判断或指定该方块能否被其他的方块右键放置而替换掉，例如空气，草，高草

protected static void addCollisionBoxToList(BlockPos pos, AxisAlignedBB entityBox, List<AxisAlignedBB> collidingBoxes, @Nullable AxisAlignedBB blockBox){}
//如果传入的blockBox经过pos大小的平移，能够和entityBox交叉的话，就将blockBox添加到colldingBoxes中，因为一个方块可能有多个碰撞箱

public void updateTick(World worldIn, BlockPos pos, IBlockState state, Random rand)
{
//当setTickRandomly(true)时，这个方法被调用，执行方块在更新时的操作
/*if(state.getBlock(pos.up(1)).equals(DIAMOND_BLOCK)) //判断当前方块位置上方一格是不是钻石块
worldIn.getNearestAttackablePlayer(pos，128，128).attackEntityFrom(DamageSource.MAGIC,10); //搜寻xyz方向上128格内最近的玩家并给予10点药水伤害
}
public void randomDisplayTick(IBlockState stateIn, World worldIn, BlockPos pos, Random rand)
{
//由于是渲染有关，因此这个方法是客户端限定的，是的，任何涉及渲染的方法都应该是SideOnly(Side.CILENT)，这个方法只在渲染tick时更新
}
public void onBlockDestroyedByPlayer(World worldIn, BlockPos pos, IBlockState state)
{
//定义了当玩家破坏这个方块之后触发的行为
if(pos.getX()==677&&pos.getZ()==788）
worldIn.getNearestAttackablePlayer(pos，2，2).setPositionAndUpdate(1，1，1)；
//破坏方块后获取（4，4，4）范围内最近的玩家，传送到（1，1，1）坐标
}
public void onBlockAdded(World worldIn, BlockPos pos, IBlockState state)
{
NBTTagCompound nbt=new NBTTagCompound();
nbt.setString("player",getNearestPlayer(pos,1,1));
//方块在区块生成之后未更新TileEntity之前进行的操作
if(hasTileEntity）
world.getTileEntity(pos).writeToNBT(nbt);
}
public void breakBlock(World worldIn, BlockPos pos, IBlockState state){
//在服务端被调用，破坏方块后TileEntity被改变前起效，可以用来实现保险箱
TileEntity te=worldIn.getTileEntity(pos);
if(te!=null) {
    NBTTagCompound nbtTagCompound = new NBTTagCompound();
    nbtTagCompound.setTag("Tile", te.getTileData());
    ItemStack itemStack = new ItemStack(this);
    itemStack.writeToNBT(nbtTagCompound);
    EntityItem entityItem=new EntityItem(worldIn,player.posX,player.posY,player.posZ,itemStack);
    entityItem.setInfinitePickupDelay();        //掉落物将不会消失
    entityItem.setEntityInvulnerable(true);   //掉落在世界中的物品是EntityItem，setEntityInvulnerable(true)可确保物品不被岩浆等外力破坏，类似于匠魂工具
    worldIn.spawnEntity(entityitem);
}}

public int quantityDropped(Random random)
{   //根据传入的随机参数，指定破坏方块时掉落物品的数量
    return 1;
}

public Item getItemDropped(IBlockState state, Random rand, int fortune)
{   //保持默认实现就好，当然你可以让它掉落点别的
    //return Item.getItemFromBlock(this);
    //以下是demo
    if(rand.nextFloat()>0.99)
       return Items.DIAMOND;//1%几率得到钻石
}

public void dropBlockAsItemWithChance(World worldIn, BlockPos pos, IBlockState state, float chance, int fortune)
{
   //将方块概率掉落为物品
   List<ItemStack> drops = getDrops(worldIn, pos, state, fortune);//fortune是时运等级
   if(1<chance<100) //方便表述请勿吐槽
   for(ItemStack drop:drops)
   spawnAsEntity(worldIn, pos, drop);
}

public static void spawnAsEntity(World worldIn, BlockPos pos, ItemStack stack) //将方块掉落成掉落物(EntityItem)的方法
{
    if (!worldIn.isRemote && !stack.isEmpty() && worldIn.getGameRules().getBoolean("doTileDrops")&& !worldIn.restoringBlockSnapshots) // do not drop items while restoring blockstates, prevents item dupe
{
        if (captureDrops.get())
        {
            capturedDrops.get().add(stack);
            return;
        }
        float f = 0.5F;
        double d0 = (double)(worldIn.rand.nextFloat() * 0.5F) + 0.25D;
        double d1 = (double)(worldIn.rand.nextFloat() * 0.5F) + 0.25D;
        double d2 = (double)(worldIn.rand.nextFloat() * 0.5F) + 0.25D;
        EntityItem entityitem = new EntityItem(worldIn, (double)pos.getX() + d0, (double)pos.getY() + d1, (double)pos.getZ() + d2, stack);
        entityitem.setEntityInvulnerable(true);  //在这里重写方法，掺杂私货      
        entityitem.setDefaultPickupDelay();
        worldIn.spawnEntity(entityitem);//最后调用的核心方法
    }
}

public void dropXpOnBlockBreak(World worldIn, BlockPos pos, int amount){
   //方块被破坏时掉落amount数量的经验   
   worldIn.spawnEntity(new EntityXPOrb(worldIn, (double)pos.getX() + 0.5D, (double)pos.getY() + 0.5D, (double)pos.getZ() + 0.5D, amount));
   //经验球是实体，EntityXPOrb就是，其构造器为EntityXPOrb(World，double，double，double，amount)，amount是总经验值
}

public int damageDropped(IBlockState state)
{
    //在这里根据方块的metadata值获取掉落物的meta
}

public void onBlockDestroyedByExplosion(World worldIn, BlockPos pos, Explosion explosionIn)
{
//当这个方块被爆炸破坏时做些什么
   EntityLivingBase sb=explosionIn.getExplosivePlacedBy();
   if(sb==暮色森林的红帽地精）
   sb.setDead();//弄死这个sb地精
}

@SideOnly(Side.CLIENT)
public BlockRenderLayer getBlockLayer()
{
    return BlockRenderLayer.SOLID;
    //获取方块的渲染层
}public boolean canPlaceBlockOnSide(World worldIn, BlockPos pos, EnumFacing side)
{
    //方块是否可以放在某个位置的某个面
    return this.canPlaceBlockAt(worldIn, pos);
}
public boolean canPlaceBlockAt(World worldIn, BlockPos pos)
{   //方块是否可以放在某个位置
    return worldIn.getBlockState(pos).getBlock().isReplaceable(worldIn, pos);
    //一般只有空气和草才是isReplaceable的
}

public boolean onBlockActivated(World worldIn, BlockPos pos, IBlockState state, EntityPlayer playerIn, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ)
{
    //用来控制玩家右击方块时做什么，是的这是一个重要方法
    playerIn.displayGui((IInteractionObject)worldIn.getTileEntity);//打开机器的GUI，如果它真的可交互的话
    world.newExplosion(new EntityTNTPrimed(world),pos.getX(),pos.getY(),pos.getZ(),7,true,true) //在方块所在的地方引发一场烈度为7，有烟和火焰的点燃TNT爆炸
    commandBanIp.execute();//执行banip指令
}
public void onEntityWalk(World worldIn, BlockPos pos, Entity entityIn)
{
   //当实体站在这个方块上时会发生什么
   if(entityIn instanceof EntityWither)
   entityIn.setDead()；
}

public void onBlockClicked(World worldIn, BlockPos pos, EntityPlayer playerIn)
{
  //决定玩家点击方块时发生什么
  worldIn.getBlockState(pos).getBlock().spawnAsEntity()；
}
public Vec3d modifyAcceleration(World worldIn, BlockPos pos, Entity entityIn, Vec3d motion)
{   //传入一个3d向量，以调节方块的加速度
    return motion;
}

public void onEntityCollidedWithBlock(World worldIn, BlockPos pos, IBlockState state, Entity entityIn)
{
  //当方块与实体碰撞时做些什么
  (EntityEgg)entityIn.getThrower();
}

public void harvestBlock(World worldIn, EntityPlayer player, BlockPos pos, IBlockState state, @Nullable TileEntity te, ItemStack stack){
    //产生这个方块的掉落物，期间方块可能会被调用Block.removedByPlayer()而移除
}
protected ItemStack getSilkTouchDrop(IBlockState state){
   //获取该方块被精准采集时的掉落物
}
public void onBlockPlacedBy(World worldIn, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack)
{
  //方块被玩家放置时做些什么
}
public boolean canSpawnInBlock()
{
     //该方法用于指定或判断生物是否可以生成在这个方块中，默认实现中可以看出，这个方块不能是solid也不能是liquid
    return !this.blockMaterial.isSolid() && !this.blockMaterial.isLiquid();
}

public Block setUnlocalizedName(String name)
{
    //设置这个方块的本地化名称，这个名字将会在汉化文件中被翻译者翻译
    this.unlocalizedName = name;
    return this;
}

public String getLocalizedName()
{
    return I18n.translateToLocal(this.getUnlocalizedName() + ".name");
}

public String getUnlocalizedName()
{
    return "tile." + this.unlocalizedName;
}

public void onFallenUpon(World worldIn, BlockPos pos, Entity entityIn, float fallDistance)
{   
    //决定实体在掉到这个方块上时的伤害加成
    entityIn.fall(fallDistance, 1.0F); //fallDistance：摔落高度，1.0F：伤害加成因数，设为0可以免伤
}


public void getSubBlocks(CreativeTabs itemIn, NonNullList<ItemStack> items)
{   //获取一个有相同id但是不同meta的方块列表
     //CreativeTabs：原版自带的创造物品栏标签，例如建筑方块，装饰方块，杂项等
    items.add(new ItemStack(this));
}

public void onBlockHarvested(World worldIn, BlockPos pos, IBlockState state, EntityPlayer player)
{
   //比breakBlock()晚，前者在tileentity被改变前起作用，这个方法在方块被设为空气（破坏）前起作用，但依旧是方块被破坏时进行的操作
}

public void fillWithRain(World worldIn, BlockPos pos)
{
   //和randomTick()一样，但是这个方法只在下雨时执行
   for(Entity entity:getEntitiesWithinAABBexcluding(world.getEntityById（23)，AABB/*玩家指定的长方体碰撞箱，这里不特意声明*/，null)
         entity.attackEntityFrom(DamageSource.LIGHTNING_BOLT, 5.0F); //让id是23的那个实体被雷劈
}


public boolean canDropFromExplosion(Explosion explosionIn)
{   
    //指定或判定这个方块会不会在爆炸中掉落下来
    return true；
}

public boolean isAssociatedBlock(Block other)
{   
    //判断这个方块和其他方块一样，没什么用
    return this == other;
}

public BlockStateContainer getBlockState()
{   
    //获取方块状态（BlockState)
    return this.blockState;
}

protected final void setDefaultState(IBlockState state)
{   
    //设置默认的BlockState
    this.defaultBlockState = state;
}

public final IBlockState getDefaultState()
{   
    //获取默认的BlockState
    return this.defaultBlockState;
}

/**
* Get the OffsetType for this Block. Determines if the model is rendered slightly offset.
*/
public Block.EnumOffsetType getOffsetType(){     
    return Block.EnumOffsetType.NONE;}

@SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, @Nullable World player, List<String> tooltip, ITooltipFlag advanced){
    //当你在物品栏或者JEI里查看物品时，会有一些工具的描述，例如“我在东北玩泥巴”，“略显邪恶”，这就是tooltip
   tooltip.add("Hunluan"); //你的tooltip里面会出现hunluan字眼
}

public float getSlipperiness(IBlockState state, IBlockAccess world, BlockPos pos, @Nullable Entity entity)
{
    //获取这个方块的滑度，其值介于0-1之间，冰的滑度为0.98
    return slipperiness;
    //this.slipperiness=0.5；在Block构造器内指定方块的滑度
}

public void setDefaultSlipperiness(float slipperiness)
{   
    //设置这个方块的滑度
    this.slipperiness = slipperiness;
}


public int getLightValue(IBlockState state, IBlockAccess world, BlockPos pos)
{   
    //获取某一方块位置的亮度
    return state.getLightValue();
}

public boolean isLadder(IBlockState state, IBlockAccess world, BlockPos pos, EntityLivingBase entity) {
      //设置一个方块能不能当作梯子使用
      return false;
}



先上一张思维导图：

下方继承上方，绿色代表抽象类，黄色代表类（如果看不清吱一声，我发一下ppt），可以看出各种实体之间的继承关系，例如EntityMob（怪物）和EntityAnimal（动物）都派生自EntityCreature，而EntityPlayer则直接来自EntityLivingBase。
每声明一个Entity，都会有一个样板代码：
public class EntityPig extends EntityAnimal
{
    private static final DataParameter<Boolean> SADDLED = EntityDataManager.createKey(EntityPig.class, DataSerializers.BOOLEAN);//SADDLED：这头猪是否配了鞍具
    private static final DataParameter<Integer> BOOST_TIME = EntityDataManager.createKey(EntityPig.class, DataSerializers.VARINT);//BOOST_TIME：用胡萝卜钓竿给猪加速的时间
}
EntityDataManager负责服务端与客户端之间的实体数据同步，DataSerializer负责数据类型的序列化（或者说持久化保存）。
生物（也包括玩家）的属性绝大多数情况下由SharedMonsterAttributes（SMA）这个类指定：
//这些是SMA类的字段
//最大血量，默认20，最大1024，但其实可以指定更大的值例如2048
public static final IAttribute MAX_HEALTH = (new RangedAttribute((IAttribute)null, "generic.maxHealth", 20.0D, Float.MIN_VALUE, 1024.0D)).setDescription("Max Health").setShouldWatch(true);
//怪物会发现并尾随的距离，默认是32，恶魂高达100，卫道士只有12
public static final IAttribute FOLLOW_RANGE = (new RangedAttribute((IAttribute)null, "generic.followRange", 32.0D, 0.0D, 2048.0D)).setDescription("Follow Range");
//击退抗性，1可以完全抗击退
public static final IAttribute KNOCKBACK_RESISTANCE = (new RangedAttribute((IAttribute)null, "generic.knockbackResistance", 0.0D, 0.0D, 1.0D)).setDescription("Knockback Resistance");
//移动速度，默认0.7，最高1024，当然没人会真以1024的速度冲出去，保证崩溃
public static final IAttribute MOVEMENT_SPEED = (new RangedAttribute((IAttribute)null, "generic.movementSpeed", 0.7D, 0.0D, 1024.0D)).setDescription("Movement Speed").setShouldWatch(true);
//飞行速度，鹦鹉是0.4，最高是1024，有必要说明的是，玩家，末影龙，凋灵的“飞行”不是靠FLYING_SPEED指定的，换句话说，这些不是飞行
public static final IAttribute FLYING_SPEED = (new RangedAttribute((IAttribute)null, "generic.flyingSpeed", 0.4D, 0.0D, 1024.0D)).setDescription("Flying Speed").setShouldWatch(true);
//攻击伤害，默认为2也就是一颗心，最高2048
public static final IAttribute ATTACK_DAMAGE = new RangedAttribute((IAttribute)null, "generic.attackDamage", 2.0D, 0.0D, 2048.0D);
//攻击速度，默认为4，实际上的武器攻速会根据“Tool Modifier”来减慢，例如剑的的Tool Modifier就是2.4，攻速是4-2.4=1.6
public static final IAttribute ATTACK_SPEED = (new RangedAttribute((IAttribute)null, "generic.attackSpeed", 4.0D, 0.0D, 1024.0D)).setShouldWatch(true);
//护甲值（不一定要有护甲），默认是0，最高是30
public static final IAttribute ARMOR = (new RangedAttribute((IAttribute)null, "generic.armor", 0.0D, 0.0D, 30.0D)).setShouldWatch(true);
//护甲韧性，默认0，最高20
ACTUAL_DAMAGE（实际伤害） = ATTACK_DAMAGE * ( 1 - min( 20, max( ARMOR / 5, ARMOR - ATTACK_DAMAGE / ( 2 + ( ARMOR_TOUGHNESS / 4 ) ) ）) / 25 )，取自minecraft wiki
public static final IAttribute ARMOR_TOUGHNESS = (new RangedAttribute((IAttribute)null, "generic.armorToughness", 0.0D, 0.0D, 20.0D)).setShouldWatch(true);
//幸运，目前只与钓鱼有关，跟时运是两回事
public static final IAttribute LUCK = (new RangedAttribute((IAttribute)null, "generic.luck", 0.0D, -1024.0D, 1024.0D)).setShouldWatch(true);

//指定属性可以在构造器中，也可以在专门的方法中
public EntityXXX(){     
     //获取EntityXXX的最大血量，设定成256
    getAttribute(SharedMonsterAttributes.MAX_HEALTH).setBaseValue(256);
    this.immuneToFire(true);//设置生物免疫火焰伤害
}

生物是有AI的，例如攻击其他生物，捡拾物品，以及和村民交配等。
要添加AI只需在你自己的Entity构造器或者专门方法中输入语句：
public void initEntityAI(){
    this.tasks.addTask(6, new EntityAILookIdle(this));  //6代表优先级，数字越小越高
    //addTask负责将相应的AI添加到生物当中
}

以下是AI表：
EntityAttackAIMelee：俗称大乱斗AI，实体会主动搜寻目标并展开攻击
EntityAttackAIRanged：远程攻击AI，原版女巫，凋灵这样能远程攻击的生物拥有
EntityAttackAIRangedBow：用弓箭的远程攻击AI，很明显，默认给骷髅用的
EntityAIAvoidEntity：避开某个实体，例如苦力怕避开猫，骷髅避开狼
EntityAIBeg：狼跟着拿着骨头的玩家走的AI，没什么用处
EntityAIBreakDoor：破门AI，仅限困难模式的僵尸
EntityAICreeperSwell：专属于苦力怕膨胀准备爆炸的AI，没什么用处
EntityAIDefendVillage：保护村庄的AI，默认铁傀儡拥有
EntityAIEatGrass：吃草方块使之变成泥土的AI，默认羊拥有
EntityAIFindEntityNearest：搜寻最近实体的AI
EntityAIFindEntityNearestPlayer：搜寻附近玩家的AI
EntityAIFleeSun：躲避阳光的AI，如果生物没有着火，此AI不会执行
EntityAIFollow：跟随实体的AI
EntityAIFollowGolem：跟随铁傀儡的AI，小村民（getGrowingAge()<0）且在白天才会触发，这时小村民会从铁傀儡手中接过花
EntityAIFollowOwner：跟随主人的AI，猫，鹦鹉，狼和马等默认拥有
EntityAIFollowOwnerFlying：跟随飞行主人并在主人落地后传送的AI，默认狼拥有
EntityAIFollowParent：幼体动物跟随父母的AI
EntityAIHarvestFarmland：收割作物的AI，默认村民拥有
EntityAIHurtByTarget：回击AI，当被打击的实体拥有这个AI时，便会展开反击，如果是群居动物例如僵尸猪人，会alertOthers()呼叫同类展开攻击
EntityAILandOnOwnersShoulder：落在主人肩膀上，很明显是鹦鹉，如果你写了个宠物调用这个AI不错
EntityAILeapAtTarget：跳跃着扑向对方的AI，要在距离在4-16之间才可能起效
EntityAILlamaFollowCaravan：一群羊驼跟着拴绳走的AI，开发者可以重新实现一下变成其他生物跟着走的AI
EntityAILookAtTradePlayer:这会看向与其交易的玩家，是的，村民专属
EntityAILookAtVillager：当铁傀儡手上有花时，它会看向村民，尝试给村民花朵
EntityAILookIdle：实体什么也不做，四处瞎看
EntityAIMate：实体交配的AI
EntityAIMoveIndoors：当下雨天时，村民会尝试躲进门里的AI
EntityAIMoveThroughVillage：主动搜寻最近的门找到村庄的AI，默认僵尸和铁傀儡有
EntityAIMoveToBlock：移动到某一方块的AI
EntityAIMoveTowardsRestriction：这个AI限制了实体的活动范围，它们离开一定距离后便会向“家”走去，-1代表距离无限，实体一定会受限
EntityAIMoveTowardsTarget：这个AI让实体接近它的目标，如果目标离实体太远超过最大距离，这个AI便不会执行
EntityAINearestAttackableTarget:这个AI允许实体寻找最近的可以攻击的实体
EntityAIOcelotAttack：顾名思义，猫发起攻击的AI
EntityAIOcelotSit：猫主动寻找熔炉和箱子坐下的AI
EntityAIOpenDoor：开门的AI，默认村民专属
EntityAIOwnerHurtByTarget：主人被其他生物攻击时，被驯服的动物所采取的动作
EntityAIOwnerHurtTarget：主人攻击其他生物时，被驯服的动物采取的动作
EntityAIPanic：动物被搭上时惊慌乱跑的AI
EntityAIPlay：小村民专属的AI，他们会互相追逐打闹
EntityAIRunAroundLikeCrazy：字面意思，四处乱跑的AI
EntityAISit：实体在主人命令下坐下的AI
EntityAISkeletonRiders：生成骷髅骑士的AI
EntityAISwimming：只有具有这个AI的实体才会游泳
EntityAITempt：动物会被玩家手上的诱饵所吸引的AI
EntityAITradePlayer：和玩家交易的AI
EntityAIVillagerInteract：村民之间分享和交换物品的AI
EntityAIVillagerMate：村民交配的AI
EntityAIWander：无目的的漫游AI
EntityAIWanderAvoidWater：对于不会游泳的实体来说，建议添加这个AI，这样它们不会往水里走
EntityAIWatchClosest：看向最近的实体，如果有攻击对象，会把最近的实体设置为攻击对象
EntityAIWatchClosest2：与前一条完全一致，除了setMutexBits（3）。
注意：setMutexBits所指定的参数，规定了当不同的ai冲突时，该在什么地方互斥

大体上来说，原版提供的AI就能满足绝大多数的需求，但是如果玩家想要自定义AI，就需要实现EntityAIBase抽象类：

1. package net.minecraft.entity.ai;
   
2. 
   
3. public abstract class EntityAIBase
   
4. {
   
5. //并行因子，如果是0，这个AI可以和其他AI并行执行（例如僵尸一边追赶玩家一边踩碎海龟蛋）
   
6.     private int mutexBits;
   
7. 
   
8. //在这里指定，AI什么时候可以执行
   
9.     public abstract boolean shouldExecute();
   
10. 
    
11. //在这里指定，什么时候AI可以继续执行，一般来说和AI何时执行是同一个条件
    
12.     public boolean shouldContinueExecuting()
    
13.     {
    
14.         return this.shouldExecute();
    
15.     }
    
16. 
    
17. //在执行这个AI时，如果这个方法返回true，那么AI将可以被优先级更高的AI打断
    
18.     public boolean isInterruptible()
    
19.     {
    
20.         return true;
    
21.     }
    
22. 
    
23. //开始执行AI,在这里实现AI的动作
    
24.     public void startExecuting()
    
25.     {
    
26.     }
    
27. 
    
28. //重置AI状态，用于当前AI被高优先级AI打断时
    
29.     public void resetTask()
    
30.     {
    
31.     }
    
32. 
    
33. //AI的持续动作，不重要
    
34.     public void updateTask()
    
35.     {
    
36.     }
    
37. 
    
38. //指定并行因子，一般不用管，或者设置成0.
    
39.     public void setMutexBits(int mutexBitsIn)
    
40.     {
    
41.         this.mutexBits = mutexBitsIn;
    
42.     }
    
43. 
    
44. //获取其并行因子
    
45.     public int getMutexBits()
    
46.     {
    
47.         return this.mutexBits;
    
48.     }
    
49. }

复制代码

例程：

1. package net.xxx.entity.ai;
   
2. 
   
3. public abstract class EntityAISleepWithSeashell extends EntityAIBase
   
4. {
   
5. private int mutexBits;
   
6. private YourEntity yourEntity;
   
7. 
   
8. public EntityAISleepWithSeashell（YourEntity entity）{
   
9.     this.yourEntity=entity；     
   
10. }
    
11. 
    
12. 
    
13. public abstract boolean shouldExecute(){
    
14. //获取最近的海螺实体
    
15. <font color="Black"><i>EntitySeashell seashell=entity.world.findNearestEntityWithinAABB(EntitySeashell.class,new AABB(blockpos1,blockpos2),entity);</i></font>
    
16. if(entity.getDistanceSq（seashell）<64)
    
17. return true；//当和实体距离小于64时，AI开始执行
    
18. 
    
19. }
    
20. 
    
21. //在这里指定，什么时候AI可以继续执行，一般来说和AI何时执行是同一个条件
    
22. public boolean shouldContinueExecuting()
    
23. {
    
24. return this.shouldExecute();
    
25. }
    
26. 
    
27. //在执行这个AI时，如果这个方法返回true，那么AI将可以被优先级更高的AI打断
    
28. public boolean isInterruptible()
    
29. {
    
30. return true;
    
31. }
    
32. 
    
33. //开始执行AI,在这里实现AI的动作
    
34. public void startExecuting()
    
35. {
    
36.     yourEntity.undress（seashell）；//脱衣服……咳咳，少儿不宜
    
37. }
    
38. 
    
39. //重置AI状态，用于当前AI被高优先级AI打断时
    
40. public void resetTask()
    
41. {
    
42.     entityZombie.setDead()；//杀死那个坏你好事的僵尸
    
43. }
    
44. 
    
45. //AI的持续动作，不重要
    
46. public void updateTask()
    
47. {
    
48. }
    
49. 
    
50. //指定并行因子，一般不用管，或者设置成0.
    
51. public void setMutexBits(int mutexBitsIn)
    
52. {
    
53. this.mutexBits = mutexBitsIn;
    
54. }
    
55. 
    
56. //获取其并行因子
    
57. public int getMutexBits()
    
58. {
    
59. return this.mutexBits;
    
60. }
    
61. }

复制代码

1. public Set<String> getTags()
   
2.     {
   
3. //获取实体所有的NBT，如果NBT长度超过1024，你将不能添加更多的标签
   
4.         return this.tags;
   
5.     }

复制代码

1. public void setDead()
   
2.     {
   
3. //直接杀死实体
   
4.         this.isDead = true;
   
5.     }

复制代码

1.12的forge有三种注册的方式——有点乱，但是值得介绍。
方法1：forge推荐的方法，就是看上去比较麻烦：
@Mod.EventBusSubscriber
public static class ObjectRegistryHandler {
    @SubscribeEvent
    public static void addItems(RegistryEvent.Register<Item> event) { //注册物品，因此泛型参数是Item，下同         
         event.getRegistry().register(new Item().setRegistryName(MOD_ID,"ustc_zzzz").setCreativeTab(yourCreativeTab).setUnlocalizedName("ustc_zzzz"));   
         //setRegistryName()：注册名，setCreativeTab()：指定创造物品栏，setUnlocalizedName()：指定本地化名称
    }

    @SubscribeEvent
    public static void addBlocks(RegistryEvent.Register<Block> event) {注册方块，泛型参数是Block
         event.getRegistry().register(new Block().setRegistryName(modid,"ustc_zzzz").setCreativeTab(yourCreativeTab));
    }
}
方法2：ForgeRegistries注册：
ForgeRegistries.Items.register(new Item().setRegistryName());
方法3：GameData注册：
GameData.register_impl(new Item().setRegistryName());
（2和3本质上是一回事，但所属的类不同）
那么为什么forge会有这样的注册系统呢？这算是历史遗留了（1.13之后forge痛定思痛，把GameRegistry砍掉，GameData转为内部测试类，失去价值），真正有用的是IForgeRegistry<T>接口和它的实现类IForgeRegistry<T>.Impl，不信请看Item类的声明：
public class Item extends net.minecraftforge.registries.ForgeRegistryEntry<Item> implements IItemProvider, net.minecraftforge.common.extensions.IForgeItem {
//一堆又臭又长跟魔熊的裹脚布一样的代码
}
public abstract class ForgeRegistryEntry<V extends IForgeRegistryEntry<V>> implements IForgeRegistryEntry<V>{
//这次不是裹脚布了
}
原版所有实现了IForgeRegistryEntry<V>的类被罗列在ForgeRegistries类中：
public static final IForgeRegistry<Block>        BLOCKS       = GameRegistry.findRegistry(Block.class);
public static final IForgeRegistry<Item>         ITEMS        = GameRegistry.findRegistry(Item.class);
public static final IForgeRegistry<Potion>       POTIONS      = GameRegistry.findRegistry(Potion.class);
public static final IForgeRegistry<Biome>        BIOMES       = GameRegistry.findRegistry(Biome.class);
public static final IForgeRegistry<SoundEvent>   SOUND_EVENTS = GameRegistry.findRegistry(SoundEvent.class);
public static final IForgeRegistry<PotionType>   POTION_TYPES = GameRegistry.findRegistry(PotionType.class);
public static final IForgeRegistry<Enchantment>  ENCHANTMENTS = GameRegistry.findRegistry(Enchantment.class);
public static final IForgeRegistry<VillagerProfession> VILLAGER_PROFESSIONS = GameRegistry.findRegistry(VillagerProfession.class);
public static final IForgeRegistry<EntityEntry>  ENTITIES     = GameRegistry.findRegistry(EntityEntry.class);
public static final IForgeRegistry<IRecipe>      RECIPES      = GameRegistry.findRegistry(IRecipe.class);方块，物品，药水，群系，声音事件，药水类型，附魔，村民职业，实体，合成。
那么没有实现IForgeRegistryEntry<V>的怎么办呢？就要靠GameRegistry类了，例如：
public static void registerWorldGenerator(IWorldGenerator generator, int modGenerationWeight)
{
   //modGenerationWeight：mod生成物权重
}
public static void addShapedRecipe(ResourceLocation name, ResourceLocation group, @Nonnull ItemStack output, Object... params)
{
    ShapedPrimer primer = CraftingHelper.parseShaped(params);
     //GameRegistry.register()在1.12较新版本变成private，开发者无法直接调用以注册，以此促进event.getRegister()的使用
    GameRegistry.register(new ShapedRecipes(group == null ? "" : group.toString(), primer.width, primer.height, primer.input, output).setRegistryName(name));
}
public static void registerTileEntity(Class<? extends TileEntity> tileEntityClass, String key) //该方法在1.13被移除
{
    // As return is ignored for compatibility, always check namespace
GameData.checkPrefix(new ResourceLocation(key).toString());
    TileEntity.register(key, tileEntityClass);//这一点使用了原版方法，也就是说原版注册不是不可使用的
}
private static <K extends IForgeRegistryEntry<K>> K register(K object)
{
    //通过GameRegistry.register注册到游戏中的实现了IForgeRegistryEntry的东西，本质上是GameData注册的
    return (K)GameData.register_impl(object);
}

一些开发者表示：我爱简洁，不想要那劳什子的event.getRegistry()，GameRegistry.register()不让用，那我就GameData好了，多简洁！然后你就不得不面对这样的问题：不同的开发者会把东西注册到不同的加载阶段导致一些不可预料的后果，在这种背景之下，forge推出了RegistryEvent.Register类，谋求一个统一的加载。


虽然MC是有一些onXXX（）方法，来监听游戏中发生的特定动作，但是这并不够，而且你也没办法从这些返回void的方法中获取到什么——想想一个很常见的需求，我只需要监听苦力怕死亡的瞬间，来做出一个特定的动作（例如复活），但是你又没办法覆写原版的方法去更改苦力怕死亡时的行为——于是事件系统应运而生，所有的事件（Event）都是forge把相关的代码打补丁写进MC源码中进而起效的，你可以在ForgeHooks类中看到forge的“小动作”，看看原版方法都会触发哪些事件。
使用一个事件其实很简单，只需要这么做：
@SubcribeEvent //forge用来监听事件的注解
public void doSomething（Event event）{
     //todo 实现你想要做的
     //监听事件不需要返回什么东西，所以一律是void
}
是的，就是这么简单，让我们看看默认提供的事件（比罗列一大堆AI还要恶心）：