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

@SubscribeEvent
public void onAttach(AttachCapabilitiesEvent event)
{
    Map<ResourceLocation, ICapabilityProvider> map = Maps.newHashMap();
    if (event instanceof AttachCapabilitiesEvent.Item)
        handle(map, event.getObject(), ((AttachCapabilitiesEvent.Item) event).getItemStack());
    else if (event instanceof AttachCapabilitiesEvent.Entity)
        handle(map, event.getObject(), ((AttachCapabilitiesEvent.Entity) event).getEntity());
    else if (event instanceof AttachCapabilitiesEvent.TileEntity)
        handle(map, event.getObject(), ((AttachCapabilitiesEvent.TileEntity) event).getTileEntity());
    else
        handle(map, event.getObject(), event.getObject());
    for (ICapabilityProvider iCapabilityProvider : event.getCapabilities().values())
        handle(map, iCapabilityProvider, event.getObject());
    for (Map.Entry<ResourceLocation, ICapabilityProvider> entry : map.entrySet())
        event.addCapability(entry.getKey(), entry.getValue());
}

@Override
public void lookFor(LazyEnergyCapProvider lecp, FluxCompat.Registry r) {
    final ICapabilityProvider icp = lecp.getObject();
    if (icp == null) return;
    EnumFacing f = null;
    try {
        for (int i = 0; i < U.FANCY_FACING.length; i++) {
            f = U.FANCY_FACING[i];
            if (TeslaUtils.hasTeslaSupport(icp, f)) {
                r.register(EnergyType.TESLA, TeslaFluxCompat::factorize);
            }
        }
    } catch (Exception e) {
        MCFluxReport.addErrMsg(new ErrMsg.BadImplementation("TESLA", icp.getClass(), e, f));
    }
}

@Override
public void lookFor(LazyEnergyCapProvider lecp, FluxCompat.Registry r) {
    final ICapabilityProvider icp = lecp.getObject();
    if (icp == null || icp instanceof TileEntityFluxGen || blacklist(icp)) return;
    EnumFacing f = null;
    try {
        for (int i = 0; i < U.FANCY_FACING.length; i++) {
            f = U.FANCY_FACING[i];
            if (icp.hasCapability(CapabilityEnergy.ENERGY, f)) {
                r.register(EnergyType.FORGE_ENERGY, ForgeFluxCompat::forgeFactorize);
            }
        }
    } catch (Exception e) {
        MCFluxReport.addErrMsg(new ErrMsg.BadImplementation("Forge Energy", icp.getClass(), e, f));
    }
}

private static void forgeFactorize(LazyEnergyCapProvider lecp) {
    final ICapabilityProvider icp = lecp.getObject();
    Energy[] es = new Energy[7];
    EnumFacing f;
    int[] s = new int[7];
    int x = 0, i;
    M:
    for (i = 0; i < U.FANCY_FACING.length; i++) {
        f = U.FANCY_FACING[i];
        IEnergyStorage ies = icp.getCapability(CapabilityEnergy.ENERGY, f);
        for (int j = 0; j < x; j++) {
            if (es[j].storage == ies) {
                s[i] = j;
                continue M;
            }
        }
        es[x] = new Energy(ies);
        s[i] = x++;
    }
    lecp.update(es, s, null, false);
    if (es[0] != null && es[0].storage != null)
        CloudUtils.reportEnergy(icp.getClass(), es[0].storage.getClass(), "forge");
}

@SubscribeEvent
@SuppressWarnings("unused")
public void onPlayerClone(PlayerEvent.Clone event) {
    EntityPlayer oldPlayer = event.getOriginal();
    EntityPlayer newPlayer = event.getEntityPlayer();
    if(oldPlayer != null && newPlayer != null && !oldPlayer.getEntityWorld().isRemote) {
        List<ICapabilityImplementation<ICapabilityProvider, ? extends ISerializable>> list = this.map.get(oldPlayer.getClass());
        if(list == null) {
            return;
        }
        list.stream()
                .filter(impl -> EntityPlayer.class.isAssignableFrom(impl.getCarrierClass()))
                .filter(impl -> oldPlayer.hasCapability(impl.getCapability(), null))
                .forEach(impl -> {
                    ISerializable oldProps = oldPlayer.getCapability(impl.getCapability(), null);
                    ISerializable newProps = oldPlayer.getCapability(impl.getCapability(), null);
                    if(newProps != null && oldProps != null) {
                        newProps.readFromNBT(oldProps.writeToNBT());
                    }
                });
    }
}

public void onTileEntityCapabilityAttachEvent(AttachCapabilitiesEvent<TileEntity> event){
    ICapabilityProvider provider = new CapabilityDestinationProvider.Provider();
    boolean requiresCap = false;

    CapabilityDestinationProvider cap = provider.getCapability(CapabilityDestinationProvider.INSTANCE, null);
    for(IDestinationProvider destinationProvider : destinationProviders) {
        if(destinationProvider.isTileEntityApplicable(event.getObject())) {
            try {
                cap.addDestinationProvider(destinationProvider.getClass().newInstance());
                if(!requiresCap) {
                    requiresCap = true;
                    event.addCapability(new ResourceLocation(Constants.MOD_ID, "destinationProviderCapability"), provider);
                }
            } catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}

@Nonnull
public static ItemStack exportStackToInventory(ICapabilityProvider provider, ItemStack stack, EnumFacing side) {
    if (provider.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side)) {
        IItemHandler handler = provider.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side);
        return ItemHandlerHelper.insertItem(handler, stack, false);
    }
    return stack;
}

@Nonnull
public static ItemStack insert(ICapabilityProvider provider, ItemStack itemStack, EnumFacing side, boolean simulate) {
    if (provider.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side)) {
        IItemHandler handler = provider.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side);
        return ItemHandlerHelper.insertItem(handler, itemStack, simulate);
    }
    return ItemStack.EMPTY;
}

@Override
public ICapabilityProvider initCapabilities(@Nonnull ItemStack stack, @Nullable NBTTagCompound nbt) {
    return new FluidHandlerItemStack(stack,capacity)
    {
        @Override
        public int fill(FluidStack resource, boolean doFill) {
            if(resource == null || resource.amount < capacity)
                return 0;

            return super.fill(resource, doFill);
        }
    };
}

@Nullable
@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    FluidHandlerItemStack handlerItemStack = new FluidHandlerItemStack(stack, 128000) {
        @Override
        public boolean canFillFluidType(FluidStack fluid) {
            return fluid.getFluid().equals(FluidsRegistry.MEAT);
        }

    };
    handlerItemStack.fill(new FluidStack(FluidsRegistry.MEAT, 0), true);
    return handlerItemStack;
}

@Override
public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    if(!stack.hasTagCompound()){
        stack.setTagCompound(new NBTTagCompound());
    }
    return new CapProviderItem(Pair.of(CapabilityEnergy.ENERGY, new ItemEnergyStorage(stack, this.maxEnergy, this.maxReceive, this.maxTransmit)));
}

@Override
public ICapabilityProvider initCapabilities() {
    if(m_realProvider != null) {
        return m_realProvider.initCapabilities();
    } else {
        return super.initCapabilities();
    }
}

@Override
public ICapabilityProvider initCapabilities() {
    if (m_proxyProvider != null && Util.isPrefixInCallStack(m_modPrefix)) {
        return m_proxyProvider.initCapabilities();
    } else if (m_realProvider != null) {
        return m_realProvider.initCapabilities();
    } else {
        return super.initCapabilities();
    }
}

private void copyInventory(ICapabilityProvider from, int[][] fromSlotIds, TileEntityIronFurnace to)
{
    FurnaceType type = to.getType();
    int[][] toSlotIds = new int[][] {type.inputSlotIds, type.fuelSlotIds, type.outputSlotIds};

    IItemHandlerModifiable fromHandler = (IItemHandlerModifiable) from.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
    IItemHandlerModifiable toHandler = (IItemHandlerModifiable) to.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
    copyInventory(fromHandler, fromSlotIds, toHandler, toSlotIds);
}

@Override
public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing)
{
    return sender instanceof ICapabilityProvider
            && ((ICapabilityProvider) sender).hasCapability(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 ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
    if (MilkRegistry.isMilkRegistered() && this.getClass() == ItemMilkBottle.class)
        return new MilkBottleWrapper(stack);
    else
        return super.initCapabilities(stack, nbt);
}

@Override
public void update()
{
    if (this.getWorld().isRemote)
        return;

    for (EnumFacing dir : EnumFacing.VALUES)
    {
        EnumFacing side = dir.getOpposite();
        BlockPos pos = this.getPos().offset(dir);

        ICapabilityProvider provider = this.getWorld().getTileEntity(pos);
        if (provider == null)
            continue;

        IEnergyStorage storage = null;
        if (provider.hasCapability(CapabilityEnergy.ENERGY, side))
            storage = provider.getCapability(CapabilityEnergy.ENERGY, side);

        //TODO? Other compatible energy types?

        if (storage == null)
            continue;

        if (storage.canReceive())
            storage.receiveEnergy(POWER_PER_TICK, false);
    }
}

@Override
public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException {
    if (sender instanceof ICapabilityProvider) {
        if (((ICapabilityProvider) sender).hasCapability(ChanceCubesReference.CHANCE_CUBE_PARTICIPATION, null)) {
            final IChanceCubeParticipationCapability capability = ((ICapabilityProvider) sender).getCapability(ChanceCubesReference.CHANCE_CUBE_PARTICIPATION, null);
            final boolean isParticipating = !capability.isParticipating();
            sender.addChatMessage(new TextComponentTranslation(
                    isParticipating ?
                            "message.shearmadness:chancecube.participating" :
                            "message.shearmadness:chancecube.notparticipating"
            ));
            capability.setParticipation(isParticipating);
        }
    }
}

private static void factorize(LazyEnergyCapProvider lecp) {
    final ICapabilityProvider icp = lecp.getObject();
    Energy[] es = new Energy[7];
    EnumFacing f;
    for (int i = 0; i < U.FANCY_FACING.length; i++) {
        f = U.FANCY_FACING[i];
        es[i] = new Energy(icp, f);
    }
    lecp.update(es, new int[0], null, true);
    CloudUtils.reportEnergy(icp.getClass(), es[0].holder.getClass(), "tesla");
}

@Override
public void lookFor(LazyEnergyCapProvider lecp, FluxCompat.Registry r) {
    final ICapabilityProvider cp = lecp.getObject();
    final String cn = cp.getClass().getName();
    if (cn == null) {
        L.warn("IC2FluxCompat: An object doesn't have a class name: " + cp);
        return;
    }
    if (cn.startsWith("ic2.core") || cn.startsWith("cpw.mods.compactsolars"))
        r.register(EnergyType.EU, this::tileFactorize);
}

private void tileFactorize(LazyEnergyCapProvider lecp) {
    if (broken) return;
    final ICapabilityProvider cp = lecp.getObject();
    if (cp == null || !(cp instanceof TileEntity)) return;
    final TileEntity te = (TileEntity) cp;
    final IEnergyTile et = EnergyNet.instance.getTile(te.getWorld(), te.getPos());
    final IEnergySource esrc = et instanceof IEnergySource ? (IEnergySource) et : null;
    final IEnergySink esnk = et instanceof IEnergySink ? (IEnergySink) et : null;
    DoubleSupplier cfunc = et instanceof BasicSource ? ((BasicSource) et)::getCapacity : et instanceof BasicSink ? ((BasicSink) et)::getCapacity : null;
    DoubleSupplier efunc = et instanceof BasicSource ? ((BasicSource) et)::getEnergyStored : et instanceof BasicSink ? ((BasicSink) et)::getEnergyStored : null;
    if (IC2_TEB.isInstance(cp)) {
        Object o = null;
        try {
            o = COMPONENT.invoke(cp, IC2_ENERGY);
        } catch (Exception e) {
            MCFluxReport.sendException(e, "[IC2] FluxCompat factorize");
        }
        cfunc = doubleFunc(CAPACITY, o);
        efunc = doubleFunc(ENERGY, o);
    }
    final EUDelegate eud = new EUDelegate(cfunc, efunc, esnk, esrc);
    final EnergyTile[] es = new EnergyTile[7];
    for (int i = 0; i < U.FANCY_FACING.length; i++) {
        EnumFacing f = U.FANCY_FACING[i];
        es[i] = new EnergyTile(eud, f);
    }
    lecp.update(es, new int[0], null, true);
    CloudUtils.reportEnergy(cp.getClass(), et.getClass(), "ic2");
}

@SuppressWarnings("unchecked")
protected  <T extends ICapabilityProvider> void addCapabilities(AttachCapabilitiesEvent<T> event) {
    Object object = event.getObject();
    T carrier = (T) object;
    Class<T> clazz = (Class<T>) carrier.getClass();
    this.map.entrySet().stream().filter(entry -> entry.getKey().isAssignableFrom(clazz)).forEach(
            entry -> entry.getValue().stream()
                    .filter(impl -> impl.getCarrierClass().isAssignableFrom(clazz))
                    .filter(impl -> impl.shouldApplyCapability(carrier))
                    .forEach(impl -> this.addCapability(event, impl, carrier)));
}

@SubscribeEvent
@SuppressWarnings("unused")
public void addEntityCapabilitiesRaw(AttachCapabilitiesEvent event) {
    if(event.getObject() instanceof ICapabilityProvider) {
        this.addCapabilities(event);
    }
}

public static boolean isPowerSource(Object object, EnumFacing facing)
{
    if (!(object instanceof ICapabilityProvider))
        return false;

    ICapabilityProvider cap = (ICapabilityProvider) object;

    Capability teslaCap = TeslaControllerBase.PRODUCER.getCapability();
    return cap.hasCapability(CapabilityEnergy.ENERGY, facing)
            || (teslaCap != null && cap.hasCapability(teslaCap, facing));
}

public static boolean isAutomatable(Object object, EnumFacing facing)
{
    if (!(object instanceof ICapabilityProvider))
        return false;

    ICapabilityProvider cap = (ICapabilityProvider) object;

    return cap.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, facing);
}

@Override
@Nullable
public ICapabilityProvider initCapabilities(@Nonnull ItemStack stack, @Nullable NBTTagCompound nbt) {
  if (!EnergyUpgrade.EMPOWERED.hasAnyUpgradeVariant(stack)) {
    EnergyUpgrade.EMPOWERED.addToItem(stack);
  }
  return super.initCapabilities(stack, nbt);
}

@Override
public IPowerInterface getPowerInterface(@Nullable ICapabilityProvider provider, @Nullable EnumFacing side) {
  if (provider != null) {
    IEnergyStorage cap = getCapability(provider, side);
    if (cap != null) {
      return new PowerInterfaceForge(provider, cap);
    }
  }
  return null;
}

@Override
public IEnergyStorage getCapability(@Nullable ICapabilityProvider provider, @Nullable EnumFacing side) {
  if (provider != null) {
    return provider.getCapability(ENERGY_HANDLER, side);
  }
  return null;
}

@Override
public IPowerInterface getPowerInterface(@Nullable ICapabilityProvider provider, @Nullable EnumFacing side) {
  if (provider != null) {
    IEnergyStorage cap = getCapability(provider, side);
    if (cap != null) {
      return new PowerInterfaceForge(provider, cap);
    }
  }
  return null;
}

@Override
public IEnergyStorage getCapability(@Nullable ICapabilityProvider provider, @Nullable EnumFacing side) {
  if (provider == null) {
    return null;
  }
  ITeslaHolder capHolder = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_HOLDER, "Tesla broke"), side);
  ITeslaConsumer capConsumer = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_CONSUMER, "Tesla broke"), side);
  ITeslaProducer capProducer = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_PRODUCER, "Tesla broke"), side);
  if (capHolder == null && capConsumer == null && capProducer == null) {
    return null;
  }
  return new TeslaToForgeAdapter(capHolder, capConsumer, capProducer);
}

public static IPowerInterface getPowerInterface(@Nullable ICapabilityProvider provider, EnumFacing side) {
  IPowerInterface res = null;
  for (IPowerApiAdapter prov : providers) {
    res = prov.getPowerInterface(provider, side);
    if (res != null) {
      return res;
    }
  }
  return res;
}

public static IEnergyStorage getCapability(@Nullable ICapabilityProvider provider, EnumFacing side) {
  IEnergyStorage res = null;
  for (IPowerApiAdapter prov : providers) {
    res = prov.getCapability(provider, side);
    if (res != null) {
      return res;
    }
  }
  return res;
}

public static ICapabilityProvider createProvider(IEnemyLevel level) 
{
    return new SimpleCapabilityProvider<>(ENEMY_LEVEL, DEFAULT_FACING, level);
}

public static ICapabilityProvider createProvider(IChunkLevelHolder chunkLevelHolder) 
{
    return new SimpleCapabilityProvider<>(CHUNK_LEVEL, DEFAULT_FACING, chunkLevelHolder);
}

public static ICapabilityProvider createProvider(IStats stats) 
{
    return new SimpleCapabilityProvider<>(STATS, DEFAULT_FACING, stats);
}

public static ICapabilityProvider createProvider(IPlayerInformation playerInfo) 
{
    return new SimpleCapabilityProvider<>(PLAYER_INFORMATION, DEFAULT_FACING, playerInfo);
}

public static ICapabilityProvider createProvider(ICurrentAbilities currentAbilities) 
{
    return new SimpleCapabilityProvider<>(CURRENT_ABILITIES, DEFAULT_FACING, currentAbilities);
}

@Nullable
public static <T> T getCapability(@Nullable ICapabilityProvider provider, Capability<T> capability, @Nullable EnumFacing facing) 
{
    return provider != null && provider.hasCapability(capability, facing) ? provider.getCapability(capability, facing) : null;
}

@Override
public ICapabilityProvider initCapabilities() {
    return super.initCapabilities();
}