@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 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(); }