cpw.mods.fml.common.Optional Java Examples

@Optional.Method(modid = ModIds.AE2)
private boolean checkForInterface(){
    if(isPlacedOnInterface()) {
        TileEntity te = getTileEntity();
        if(te instanceof IGridHost) {
            if(((IGridHost)te).getGridNode(null) == null) return true;
            if(getGridNode(null) == null) return true;
            try {
                AEApi.instance().createGridConnection(getGridNode(null), ((IGridHost)te).getGridNode(null));
            } catch(FailedConnection e) {
                Log.error("Couldn't connect to an ME Interface!");
                e.printStackTrace();
            }
        }
    }
    return false;
}
 

@Override
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
public boolean equals(IPeripheral other){
    if(other == null) {
        return false;
    }
    if(this == other) {
        return true;
    }
    if(other instanceof TileEntity) {
        TileEntity tother = (TileEntity)other;
        return tother.getWorldObj().equals(worldObj) && tother.xCoord == xCoord && tother.yCoord == yCoord && tother.zCoord == zCoord;
    }

    return false;
}
 

@Override
@Optional.Method(modid = ModIds.AE2)
public void update(){
    super.update();

    if(!world.isRemote) {
        if(needToCheckForInterface) {
            if(Loader.isModLoaded(ModIds.AE2) && !world.isRemote && aeMode && gridNode == null) {
                needToCheckForInterface = checkForInterface();
            } else {
                needToCheckForInterface = false;
            }
        }

        Iterator<Map.Entry<TileEntity, Integer>> iterator = providingInventories.entrySet().iterator();
        while(iterator.hasNext()) {
            Map.Entry<TileEntity, Integer> entry = iterator.next();
            if(entry.getValue() == 0 || entry.getKey().isInvalid()) {
                iterator.remove();
            } else {
                entry.setValue(entry.getValue() - 1);
            }
        }
    }
}
 

@Override
@Optional.Method(modid = ModIds.NEI)
public VisiblityData modifyVisiblity(GuiContainer gui, VisiblityData currentVisibility){
    for(IGuiWidget w : widgets) {
        if(w instanceof IGuiAnimatedStat) {
            IGuiAnimatedStat stat = (IGuiAnimatedStat)w;
            if(stat.isLeftSided()) {
                if(stat.getWidth() > 20) {
                    currentVisibility.showUtilityButtons = false;
                    currentVisibility.showStateButtons = false;
                }
            } else {
                if(stat.getAffectedY() < 10) {
                    currentVisibility.showWidgets = false;
                }
            }
        }
    }
    return currentVisibility;
}
 

@Override
@Optional.Method(modid = ModIds.AE2)
public void onStackChange(IItemList arg0, IAEStack arg1, IAEStack arg2, BaseActionSource arg3, StorageChannel arg4){
    if(craftingGrid != null) {
        ICraftingGrid grid = (ICraftingGrid)craftingGrid;
        for(int i = 0; i < getFilters().getSizeInventory(); i++) {
            ItemStack s = getFilters().getStackInSlot(i);
            if(s != null) {
                if(!grid.isRequesting(AEApi.instance().storage().createItemStack(s))) {
                    getFilters().setInventorySlotContents(i, null);
                    notifyNetworkOfCraftingChange();
                }
            }
        }
    }
}
 

@Optional.Method(modid = "MineFactoryReloaded")
@Override
public int[] getOutputValues(World world, int x, int y, int z,
		ForgeDirection side) {
	TileEntity te = world.getTileEntity(x, y, z);
	if(te instanceof TileEntityReactorRedNetPort) {
		return ((TileEntityReactorRedNetPort)te).getOutputValues();
	}
	else {
		int[] values = new int[16];
		for(int i = 0; i < 16; i++) {
			values[i] = 0;
		}
		return values;
	}
}
 

@Override
@Optional.Method(modid = ModIds.AE2)
public void onRequestChange(ICraftingGrid grid, IAEItemStack aeStack){
    craftingGrid = grid;
    ItemStack stack = aeStack.getItemStack().copy();
    int freeSlot = -1;
    for(int i = 0; i < getFilters().getSizeInventory(); i++) {
        ItemStack s = getFilters().getStackInSlot(i);
        if(s != null) {
            if(stack.isItemEqual(s)) {
                s.stackSize = stack.stackSize;
                if(s.stackSize == 0) getFilters().setInventorySlotContents(i, null);
                return;
            }
        } else if(freeSlot == -1) {
            freeSlot = i;
        }
    }
    if(freeSlot >= 0) {
        getFilters().setInventorySlotContents(freeSlot, stack.copy());
    }
}
 

@Override
@Optional.Method(modid = "OpenComputers")
public Object[] invoke(final String method, final Context context,
					   final Arguments args) throws Exception {
	final Object[] arguments = new Object[args.count()];
	for (int i = 0; i < args.count(); ++i) {
		arguments[i] = args.checkAny(i);
	}
	final Integer methodId = methodIds.get(method);
	if (methodId == null) {
		throw new NoSuchMethodError();
	}
	return callMethod(methodId, arguments);
}
 

@Optional.Method(modid = "MineFactoryReloaded")
@Override
public void onInputChanged(World world, int x, int y, int z,
		ForgeDirection side, int inputValue) {
	TileEntity te = world.getTileEntity(x, y, z);
	if(te instanceof TileEntityReactorRedstonePort) {
		TileEntityReactorRedstonePort port = (TileEntityReactorRedstonePort)te;
		port.onRedNetUpdate(inputValue);
	}
}
 

@Optional.Method(modid = "NotEnoughItems")
    @Override
    public void loadConfig() {
        API.hideItem(new ItemStack(ItemRegistry.TAB));
        API.hideItem(new ItemStack(FluidLoader.bioFluidBlock));
        API.hideItem(new ItemStack(ItemRegistry.bw_fake_glasses));
        ItemStack[] prefixesToHide = {
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.dustTiny, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.dustSmall, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.crushed, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.crushedPurified, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.crushedCentrifuged, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.nugget, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.gemChipped, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.gemFlawed, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.gemFlawless, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.gemExquisite, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.dustImpure, WerkstoffLoader.Bismutite).copy(),
                WerkstoffLoader.getCorrespondingItemStack(OrePrefixes.dustPure, WerkstoffLoader.Bismutite).copy(),
        };
        for (ItemStack stack : prefixesToHide) {
            stack.setItemDamage(Short.MAX_VALUE);
            API.hideItem(stack);
        }
//        for (int i = 0; i < Short.MAX_VALUE; i++) {
//            API.addItemListEntry(new ItemStack(WerkstoffLoader.BWOres,1,i));
//        }
    }
 

@Optional.Method(modid = ModIds.AE2)
private void updateProvidingItems(ICraftingProviderHelper cHelper){
    IStackWatcher sWatcher = (IStackWatcher)stackWatcher;
    ICraftingWatcher cWatcher = (ICraftingWatcher)craftingWatcher;
    if(sWatcher != null) sWatcher.clear();
    if(cWatcher != null) cWatcher.clear();
    for(IAEItemStack stack : getProvidingItems()) {
        if(sWatcher != null) sWatcher.add(stack);
        if(cWatcher != null) cWatcher.add(stack);
        if(cHelper != null) cHelper.setEmitable(stack);
    }
}
 

@Override
@Optional.Method(modid = ModIds.AE2)
public void invalidate(){
    super.invalidate();
    if(gridNode != null) {
        disconnectFromInterface();
    }
}
 

@Optional.Method(modid = ModIds.AE2)
private void notifyNetworkOfCraftingChange(){
    if(gridNode != null) {
        IGrid grid = ((IGridNode)gridNode).getGrid();
        if(grid != null) grid.postEvent(new MENetworkCraftingPatternChange(this, (IGridNode)gridNode));
    }
}
 

@SuppressWarnings("rawtypes")
@Optional.Method(modid = "tectech")
private boolean areThingsProperlyTiered(Collection collection) {
    if (!collection.isEmpty())
        for (Object tecTechEnergyMulti : collection)
            if (((GT_MetaTileEntity_TieredMachineBlock) tecTechEnergyMulti).mTier > this.glasTier)
                return false;
    return true;
}
 

@SuppressWarnings("rawtypes")
@Optional.Method(modid = "tectech")
private boolean areLazorsLowPowa() {
    Collection collection = this.getTecTechEnergyTunnels();
    if (!collection.isEmpty())
        for (Object tecTechEnergyMulti : collection)
            if (!(tecTechEnergyMulti instanceof LowPowerLaser))
                return false;
    return true;
}
 

@Optional.Method(modid = "ComputerCraft")
@Override
public IPeripheral getPeripheral(World world, int x, int y, int z, int side) {
	TileEntity te = world.getTileEntity(x, y, z);
	
	if(te instanceof TileEntityTurbineComputerPort)
		return (IPeripheral)te;
	
	return null;
}
 

@Optional.Method(modid = "MineFactoryReloaded")
@Override
public int getOutputValue(World world, int x, int y, int z,
		ForgeDirection side, int subnet) {
	TileEntity te = world.getTileEntity(x, y, z);
	if(te instanceof TileEntityReactorRedNetPort) {
		return ((TileEntityReactorRedNetPort)te).getValueForChannel(subnet);
	}
	return 0;
}
 

/**
 * Called on a event sensor
 * @param newRedstoneStrength
 */
@Optional.Method(modid = ModIds.COMPUTERCRAFT)
private void notifyComputers(Object... arguments){
    for(IComputerAccess computer : attachedComputers) {
        computer.queueEvent(getType(), arguments);
    }
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) {
       try {
           return callMethod(method, arguments);
       } catch(Exception e) {
       	BRLog.info("Exception encountered when invoking computercraft method: %s", e.getMessage());
           e.printStackTrace();
       }
       return null;
   }
 

@Override
@Optional.Method(modid = ModIds.AE2)
public List<IMEInventoryHandler> getCellArray(StorageChannel channel){
    if(channel == StorageChannel.ITEMS) {
        return Arrays.asList((IMEInventoryHandler)this);
    } else {
        return new ArrayList<IMEInventoryHandler>();
    }
}
 

@Optional.Method(modid = ModIds.INDUSTRIALCRAFT)
protected int getIC2Upgrades(String ic2ItemKey, int[] upgradeSlots){
    ItemStack itemStack = IC2Items.getItem(ic2ItemKey);
    if(itemStack == null) return 0;
    int upgrades = 0;
    if(this instanceof IInventory) {// this always should be true.
        IInventory inv = (IInventory)this;
        for(int i : upgradeSlots) {
            if(inv.getStackInSlot(i) != null && inv.getStackInSlot(i).getItem() == itemStack.getItem()) {
                upgrades += inv.getStackInSlot(i).stackSize;
            }
        }
    }
    return upgrades;
}
 

@Override
@Optional.Method(modid = ModIds.FMP)
public TileEntityPressureTube getTube(Object potentialTube){
    if(potentialTube instanceof PartPressureTube) {
        return ((PartPressureTube)potentialTube).getTube();
    } else if(potentialTube instanceof TileMultipart) {
        PartPressureTube tube = FMP.getMultiPart((TileMultipart)potentialTube, PartPressureTube.class);
        return tube != null ? tube.getTube() : null;
    } else {
        return super.getTube(potentialTube);
    }
}
 

@Override
@Optional.Method(modid = "OpenComputers")
public Object[] invoke(final String method, final Context context,
					   final Arguments args) throws Exception {
	final Object[] arguments = new Object[args.count()];
	for (int i = 0; i < args.count(); ++i) {
		arguments[i] = args.checkAny(i);
	}
	final Integer methodId = methodIds.get(method);
	if (methodId == null) {
		throw new NoSuchMethodError();
	}
	return callMethod(methodId, arguments);
}
 

@Override
@Optional.Method(modid = "OpenComputers")
public String getComponentName() {
	// Convention for OC names is a) lower case, b) valid variable names,
	// so this can be used as `component.br_reactor.setActive(true)` e.g.
	return "br_reactor";
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws LuaException {
       try {
           return callMethod(method, arguments);
       } catch(Exception e) {
       	// Rethrow errors as LuaExceptions for CC
       	throw new LuaException(e.getMessage());
       }
   }
 

@Optional.Method(modid = ModIds.FMP)
public void writeDesc(MCDataOutput data){
    data.writeInt(dir.ordinal());
}
 

@Optional.Method(modid = ModIds.FMP)
public void updatePart(){
    ((PartPressureTube)part).onNeighborChanged();
}
 

@Override
@Optional.Method(modid = ModIds.AE2)
public IGridNode getActionableNode(){
    return getGridNode(null);
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public String[] getMethodNames() {
	return methodNames;
}
 

@Override
@Optional.Method(modid = "ComputerCraft")
public void detach(IComputerAccess computer) {
}