net.minecraftforge.event.AttachCapabilitiesEvent Java Examples

@SubscribeEvent
public void onAttachCapabilityEventItem(AttachCapabilitiesEvent event) {
    if (event.getObject() instanceof ItemStack) {
        ItemStack stack = (ItemStack) event.getObject();
        Item item = stack.getItem();

        if (item instanceof ItemValkyriumCrystal) {
            event.addCapability(
                new ResourceLocation(ValkyrienSkiesWorld.MOD_ID, "AntiGravityValue"),
                new AntiGravityCapabilityProvider(VSConfig.valkyriumCrystalForce));
        }
        if (stack.getItem() instanceof ItemBlock) {
            ItemBlock blockItem = (ItemBlock) stack.getItem();
            if (blockItem.getBlock() instanceof BlockValkyriumOre) {
                event.addCapability(
                    new ResourceLocation(ValkyrienSkiesWorld.MOD_ID, "AntiGravityValue"),
                    new AntiGravityCapabilityProvider(VSConfig.valkyriumOreForce));
            }
        }
    }
}
 

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

@SubscribeEvent
public void initTe(AttachCapabilitiesEvent<TileEntity> event) {
	if (event.getObject() instanceof IUpgradableBlock && event.getObject() instanceof TileEntityBase) {
		TileEntityBase chest = (TileEntityBase) event.getObject();
		chest.addElement(new IC2EnergyElement(chest));
	}
}
 

@SubscribeEvent
public void initTe(AttachCapabilitiesEvent<TileEntity> event) {
	if (event.getObject() instanceof TileEntityBBarrel) {
		TileEntityBBarrel chest = (TileEntityBBarrel) event.getObject();
		event.addCapability(rl, new CapabilityHandler(chest));
	}
}
 

@SubscribeEvent
public void onAttachCapabilitiesEntity(AttachCapabilitiesEvent<Entity> event) {
	if (!BackpackRegistry.canEntityWearBackpacks(event.getObject())) return;
	// Give entities that can wear backpacks the backpack capability.
	event.addCapability(BackpackCapability.IDENTIFIER,
		new BackpackCapability.Provider((EntityLivingBase)event.getObject()));
}
 

@SubscribeEvent
public void attachCapabilities(AttachCapabilitiesEvent<ItemStack> evt)
{
	if (evt.getCapabilities().containsKey(KEY)) {
		return;
	}
	Item item = evt.getObject().getItem();
	if (item instanceof ItemSpaceArmor) {
		evt.addCapability(KEY, (ICapabilityProvider) item);
	}
}
 

@SubscribeEvent
public void attachCapabilities(AttachCapabilitiesEvent<Entity> e)
{
    if (!ConfigManager.SERVER.enableScraping.get())
        return;
    final Entity entity = e.getObject();

    if (!(entity instanceof ServerPlayerEntity))
        return;

    if (entity.world == null || entity.world.isRemote)
        return;

    e.addCapability(PROP_KEY, new ICapabilityProvider()
    {
        ItemBreakingTracker cap = new ItemBreakingTracker();
        LazyOptional<ItemBreakingTracker> cap_provider = LazyOptional.of(() -> cap);

        {
            cap.init(entity, entity.world);
        }

        @SuppressWarnings("unchecked")
        @Override
        public <T> LazyOptional<T> getCapability(Capability<T> capability, @Nullable Direction facing)
        {
            if (capability == TRACKER)
                return cap_provider.cast();
            return LazyOptional.empty();
        }
    });
}
 

@SubscribeEvent
public void onAttachCapabilityEventItem(AttachCapabilitiesEvent<ItemStack> event) {
    if (event.getObject().getItem() instanceof ItemRelayWire) {
        event.addCapability(new ResourceLocation(ValkyrienSkiesControl.MOD_ID, "LastRelay"),
            new LastNodeCapabilityProvider());
    }
}
 

@SubscribeEvent
public void attachCyberwareData(AttachCapabilitiesEvent.Entity event)
{
	if (event.getEntity() instanceof EntityPlayer)
	{
		event.addCapability(CyberwareUserDataImpl.Provider.NAME, new CyberwareUserDataImpl.Provider());
	}
}
 

@SubscribeEvent
public void onEntityLoad(AttachCapabilitiesEvent<Entity> event) {
	if (!(event.getObject() instanceof EntityPlayer)) {
		return;
	}
	EntityPlayer player = (EntityPlayer) event.getObject();
	event.addCapability(new ResourceLocation(ToroQuest.MODID, "playerCivilization"), new PlayerCivilizationCapabilityProvider(player));
	syncClientCapability(player);
}
 

@SubscribeEvent
public static void attachEntity(AttachCapabilitiesEvent<Entity> e) {
	if (e.getObject() instanceof EntityPlayer) {
		ManaCapabilityProvider manaCap = new ManaCapabilityProvider(new DefaultManaCapability());
		e.addCapability(new ResourceLocation(Wizardry.MODID, "capability_mana"), manaCap);

		MiscCapabilityProvider miscCap = new MiscCapabilityProvider(new DefaultMiscCapability());
		e.addCapability(new ResourceLocation(Wizardry.MODID, "capability_misc"), miscCap);
	}
}
 

@SubscribeEvent
public void onEntityConstructing(AttachCapabilitiesEvent<Entity> event){
    if (event.getObject() instanceof EntityPlayer) {
        if (!event.getObject().hasCapability(PlayerProperties.PLAYER_MANA, null)) {
            event.addCapability(new ResourceLocation(MyMod.MODID, "Mana"), new PropertiesDispatcher());
        }
    }
}
 

@Override
public void gatherCapabilities(@Nullable ICapabilityProvider parent) {
	AttachCapabilitiesEvent<T> event = new AttachCapabilitiesEvent<>(baseClass, provider);
	MinecraftForge.EVENT_BUS.post(event);

	if (!event.getCapabilities().isEmpty() || parent != null) {
		capabilities = new CapabilityDispatcher(event.getCapabilities(), event.getListeners(), parent);
	} else {
		capabilities = null;
	}
}
 

public void gatherCapabilities(@Nullable ICapabilityProvider parent) {
	AttachCapabilitiesEvent<B> event = new AttachCapabilitiesEvent<>(baseClass, (B) this);
	MinecraftForge.EVENT_BUS.post(event);

	if (!event.getCapabilities().isEmpty() || parent != null) {
		capabilities = new CapabilityDispatcher(event.getCapabilities(), event.getListeners(), parent);
	} else {
		capabilities = null;
	}
}
 

@SubscribeEvent
public static void onAttachCapabilities(AttachCapabilitiesEvent<Chunk> event)
{
	event.addCapability(WIZARDRY_CHUNK_ID, StandardWizardryChunk.create());
}
 

@SubscribeEvent
public static void onAttachCapabilities(AttachCapabilitiesEvent<World> event) {
	event.addCapability(WIZARDRY_WORLD_ID, StandardWizardryWorld.create(event.getObject()));
}
 

@SubscribeEvent
public void onCapabilityAttachmentEntity(AttachCapabilitiesEvent<Entity> event){
    if(event.getObject() instanceof EntityMinecart) {
        event.addCapability(new ResourceLocation(Constants.MOD_ID, "minecartDestinationCapability"), new CapabilityMinecartDestination.Provider());
    }
}
 

@SubscribeEvent(priority = EventPriority.LOWEST)
public void onCapabilityAttachmentTile(AttachCapabilitiesEvent<TileEntity> event){
    RailManager.getInstance().onTileEntityCapabilityAttachEvent(event);
}
 

@SubscribeEvent
public void onCapabilityAttachmentStack(AttachCapabilitiesEvent<ItemStack> event){
    if(event.getObject().getItem() == ModItems.TICKET) {
        event.addCapability(new ResourceLocation(Constants.MOD_ID, "ticketDestinationCapability"), new CapabilityMinecartDestination.Provider());
    }
}
 

@SubscribeEvent
public void onCapabilityAttach(AttachCapabilitiesEvent<Entity> event) {
  if(event.getObject() instanceof EntityLivingBase && event.getObject().isEntityAlive()) {
    event.addCapability(CAPABILITY_KEY, new DamageXpHandler());
  }
}
 

@SubscribeEvent
public void attachCapability(AttachCapabilitiesEvent<Entity> event) {
    if (!(event.getObject() instanceof EntityPlayer)) return;
    event.addCapability(new ResourceLocation(Reference.MODID, "stat_container"), new CapabilityStat.Provider());
}
 

@SubscribeEvent
public static void attachChunkCapabilities(AttachCapabilitiesEvent<Chunk> event) {
    event.addCapability(CAPABILITY_ID, new WorldGenCapabilityProvider());
}
 

@SubscribeEvent
public void onAttachCapabilitiesEntity(AttachCapabilitiesEvent<Entity> event)
{
    event.addCapability(EnderUtilitiesCapabilities.PORTAL_COOLDOWN_CAP_NAME, new PortalCooldownCapabilityProvider());
}
 

@SubscribeEvent
public static void onAttachEntityCapabilities(AttachCapabilitiesEvent<Entity> event) {
    event.addCapability(new ResourceLocation(CommunityGlobals.MOD_ID, "squashable"), new Squashable());
}