Java 类net.minecraftforge.common.capabilities.Capability 实例源码

@Nullable
@Override
public NBTBase writeNBT(Capability<FoodStats> capability, FoodStats instance, EnumFacing side) {
    NBTTagCompound tagCompound = new NBTTagCompound();
    tagCompound.setInteger("amount", instance.getAmount());
    tagCompound.setBoolean("wolfFood", instance.isWolfFood());
    tagCompound.setFloat("saturationModifier", instance.getSaturationModifier());
    tagCompound.setBoolean("alwaysEdible", instance.isAlwaysEdible());
    tagCompound.setInteger("maxItemUseDuration", instance.getMaxItemUseDuration());
    tagCompound.setInteger("action", instance.getAction().ordinal());
    if (instance.getPotion() != null)
        tagCompound.setTag("potion", instance.getPotion().writeCustomPotionEffectToNBT(new NBTTagCompound()));
    tagCompound.setFloat("potionEffectProbability", instance.getPotionEffectProbability());
    tagCompound.setString("unlocalizedName", instance.getUnlocalizedName());
    return tagCompound;
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (!getStack().isEmpty() && capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && facing == EnumFacing.DOWN) {
        return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(new SidedInvWrapper(this, facing));
    }
    return super.getCapability(capability, facing);
}

@SuppressWarnings("unchecked")
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
        return (T) tank;
    return super.getCapability(capability, facing);
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast(itemStackHandler);
    }
    return super.getCapability(capability, facing);
}

@Nullable
@Override
public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing)
{
    return sender instanceof ICapabilityProvider
            ? ((ICapabilityProvider) sender).getCapability(capability, facing)
            : null;
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        return (T) new MachineItemHandler(this);
    }

    return super.getCapability(capability, facing);
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
    if (capability  == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
        return (T) this.handler;
    return super.getCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (m_realPlayer == null) {
        return super.hasCapability(capability, facing);
    } else {
        return m_realPlayer.hasCapability(capability, facing);
    }
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.equals(capability)) {
        @SuppressWarnings("unchecked")
        T result = (T) Inventory;
        return result;
    }
    return super.getCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.equals(capability)) {
        return true;
    }
    return super.hasCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing)
{
    for (TileEntityModule module : modules.values())
    {
        if (module.hasCapability(capability, facing))
            return true;
    }

    return super.hasCapability(capability, facing);
}

@Override
public NBTBase writeNBT(Capability<CapabilityDivination> capability, CapabilityDivination instance, EnumFacing side) {
    NBTTagCompound tag = new NBTTagCompound();
    if (instance.getFortune() != null) {
        tag.setString("fortune", instance.getFortune().getRegistryName().toString());
        tag.setBoolean("active", instance.isActive());
        tag.setBoolean("removable", instance.isRemovable());
    }
    return tag;
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
{
    if(world.getTileEntity(pos.down()) != null)
            return world.getTileEntity(pos.down()).hasCapability(capability, facing);
    return false;
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
{
    if (facing == null && capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        return true;
    }
    return super.hasCapability(capability, facing);
}

@Nullable
@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
        return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(fluidHandler);
    }
    return super.getCapability(capability, facing);
}

@Nullable
@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
        return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(refineryFluidHandler);
    } else {
        return super.getCapability(capability, facing);
    }
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
    if (capability  == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
        return (T) this.handler;
    return super.getCapability(capability, facing);
}

@SuppressWarnings("unchecked")
@Nullable
public <T> T provide(@Nonnull RelativeDirection side, @Nonnull Capability<T> capability) {
    Validate.notNull(capability);

    for(Entry<?> entry : entries) {
        //if (side!=null) {
            if (entry.directions.contains(side) && capability.equals(entry.capability)) return (T)entry.provide();
        //} else {
        //  if (capability.equals(entry.capability)) return (T)entry.provide();
        //}
    }

    return null;
}

@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        return getPrimaryInventory() != null;
    } else {
        return super.hasCapability(capability, facing);
    }
}

@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing)
{
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
    {
        return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(new FluidHandlerWrapper(this, facing));
    }
    return super.getCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (m_realPlayer == null) {
        return super.hasCapability(capability, facing);
    } else {
        syncToRealPlayer();
        return syncPublicFieldsFromRealAndReturn(m_realPlayer.hasCapability(capability, facing));
    }
}

@Nullable
@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
        return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(tank);
    } else {
        return super.getCapability(capability, facing);
    }
}

@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing)
{
    if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
    {
        return facing == null || ArrayUtils.contains(supplier.sides, facing);
    }
    return false;
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (capability == CapabilityEnergy.ENERGY) {
        return true;
    }
    return super.hasCapability(capability, facing);
}

@SuppressWarnings("unchecked")
@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityEnergy.ENERGY && m_storage.getMaxEnergyStored() > 0)
    {
        return (T)m_storage;
    }
    return null;
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY
            || capability == ModCapabilities.CAPABILITY_WORKER)
        return true;
    return super.hasCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing)
{
    if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    {
        return true;
    }

    return super.hasCapability(capability, facing);
}

@Override
   public boolean hasCapability(Capability<?> capability, EnumFacing facing)
   {
if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
    return true;
return super.hasCapability(capability, facing);
   }

@Nullable
@Override
@SuppressWarnings("unchecked")
public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
    if (capability == CapabilityExtendedHealthSystem.INSTANCE)
        return (T) PlayerDataManager.capList.get(player);
    return null;
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
{
    if(world.getTileEntity(pos.down()) != null)
        return (T) world.getTileEntity(pos.down()).getCapability(capability, facing);
    return null;
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing){
    if (capability == EmberCapabilityProvider.emberCapability){
        return (T)this.capability;
    }
    return super.getCapability(capability, facing);
}

@SuppressWarnings("unchecked")
@Override
public <T> T getCapability (Capability<T> capability, @Nullable  EnumFacing facing) {
    if (facing != null && capability == ITEM_HANDLER_CAPABILITY)
        return (T)itemHandler;

    return super.getCapability(capability, facing);
}

public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (facing == null || capability == null) {
        return false;
    }
    if (facing.equals(EnumFacing.DOWN)) {
        return false;
    }
    if (capability == CapabilityEnergy.ENERGY) {
        return true;
    }
    return super.hasCapability(capability, facing);
}

@Nullable
@Override
public NBTBase writeNBT(Capability<T> capability, T instance, EnumFacing side) {
    if(instance instanceof INBTSerializable) {
        return ((INBTSerializable)instance).serializeNBT();
    } else {
        throw new IllegalArgumentException("Can not serialize to an instance that isn't a INBTSerializable implementation");
    }
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
{
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
        return true;
    return super.hasCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
    if(capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
        return true;
    }
    if(ModularMachinery.isMekanismLoaded) {
        if(checkMekanismGasCapabilitiesPresence(capability, facing)) {
            return true;
        }
    }
    return super.hasCapability(capability, facing);
}

@Override
public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
    if (capability == null) return false;
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
        return true;
    return super.hasCapability(capability, facing);
}

@Nullable
@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing)
{
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY &&
        (facing == null))
    {
        return (T) invHandler;
    }

    return null;
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        IItemHandler handler = this.getItemHandler();

        if (handler != null) {
            return (T) handler;
        }
    }
    return super.getCapability(capability, facing);
}

@Override
public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
    if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
        return (T) inventory;
    }
    return super.getCapability(capability, facing);
}