/* * This file is part of Applied Energistics 2. * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved. * * Applied Energistics 2 is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * Applied Energistics 2 is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with Applied Energistics 2. If not, see . */ package appeng.parts.misc; import java.util.Collections; import java.util.List; import java.util.Objects; import net.minecraft.block.entity.BlockEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.inventory.container.ContainerType; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompoundTag; import net.minecraft.util.Identifier; import net.minecraft.util.math.Direction; import net.minecraft.util.Hand; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; import net.minecraft.world.BlockView; import net.minecraftforge.common.util.LazyOptional; import net.minecraftforge.items.CapabilityItemHandler; import alexiil.mc.lib.attributes.item.FixedItemInv; import appeng.api.AEApi; import appeng.api.config.AccessRestriction; import appeng.api.config.FuzzyMode; import appeng.api.config.IncludeExclude; import appeng.api.config.Settings; import appeng.api.config.StorageFilter; import appeng.api.config.Upgrades; import appeng.api.networking.IGridNode; import appeng.api.networking.events.MENetworkCellArrayUpdate; import appeng.api.networking.events.MENetworkChannelsChanged; import appeng.api.networking.events.MENetworkEventSubscribe; import appeng.api.networking.events.MENetworkPowerStatusChange; import appeng.api.networking.security.IActionSource; import appeng.api.networking.storage.IBaseMonitor; import appeng.api.networking.ticking.IGridTickable; import appeng.api.networking.ticking.ITickManager; import appeng.api.networking.ticking.TickRateModulation; import appeng.api.networking.ticking.TickingRequest; import appeng.api.parts.IPartCollisionHelper; import appeng.api.parts.IPartHost; import appeng.api.parts.IPartModel; import appeng.api.storage.IMEInventory; import appeng.api.storage.IMEInventoryHandler; import appeng.api.storage.IMEMonitorHandlerReceiver; import appeng.api.storage.IStorageChannel; import appeng.api.storage.IStorageMonitorable; import appeng.api.storage.IStorageMonitorableAccessor; import appeng.api.storage.cells.ICellContainer; import appeng.api.storage.cells.ICellInventory; import appeng.api.storage.channels.IItemStorageChannel; import appeng.api.storage.data.IAEItemStack; import appeng.api.storage.data.IItemList; import appeng.api.util.AECableType; import appeng.api.util.AEPartLocation; import appeng.api.util.IConfigManager; import appeng.capabilities.Capabilities; import appeng.container.ContainerLocator; import appeng.container.ContainerOpener; import appeng.container.implementations.StorageBusContainer; import appeng.core.AppEng; import appeng.core.settings.TickRates; import appeng.helpers.IInterfaceHost; import appeng.helpers.IPriorityHost; import appeng.helpers.Reflected; import appeng.items.parts.PartModels; import appeng.me.GridAccessException; import appeng.me.helpers.MachineSource; import appeng.me.storage.ITickingMonitor; import appeng.me.storage.MEInventoryHandler; import appeng.me.storage.MEMonitorIInventory; import appeng.parts.PartModel; import appeng.parts.automation.UpgradeablePart; import appeng.tile.inventory.AppEngInternalAEInventory; import appeng.util.Platform; import appeng.util.inv.InvOperation; import appeng.util.prioritylist.FuzzyPriorityList; import appeng.util.prioritylist.PrecisePriorityList; public class StorageBusPart extends UpgradeablePart implements IGridTickable, ICellContainer, IMEMonitorHandlerReceiver, IPriorityHost { public static final Identifier MODEL_BASE = new Identifier(AppEng.MOD_ID, "part/storage_bus_base"); @PartModels public static final IPartModel MODELS_OFF = new PartModel(MODEL_BASE, new Identifier(AppEng.MOD_ID, "part/storage_bus_off")); @PartModels public static final IPartModel MODELS_ON = new PartModel(MODEL_BASE, new Identifier(AppEng.MOD_ID, "part/storage_bus_on")); @PartModels public static final IPartModel MODELS_HAS_CHANNEL = new PartModel(MODEL_BASE, new Identifier(AppEng.MOD_ID, "part/storage_bus_has_channel")); private final IActionSource mySrc; private final AppEngInternalAEInventory Config = new AppEngInternalAEInventory(this, 63); private int priority = 0; private boolean cached = false; private ITickingMonitor monitor = null; private MEInventoryHandler handler = null; private int handlerHash = 0; private boolean wasActive = false; private byte resetCacheLogic = 0; @Reflected public StorageBusPart(final ItemStack is) { super(is); this.getConfigManager().registerSetting(Settings.ACCESS, AccessRestriction.READ_WRITE); this.getConfigManager().registerSetting(Settings.FUZZY_MODE, FuzzyMode.IGNORE_ALL); this.getConfigManager().registerSetting(Settings.STORAGE_FILTER, StorageFilter.EXTRACTABLE_ONLY); this.mySrc = new MachineSource(this); } @Override @MENetworkEventSubscribe public void powerRender(final MENetworkPowerStatusChange c) { this.updateStatus(); } private void updateStatus() { final boolean currentActive = this.getProxy().isActive(); if (this.wasActive != currentActive) { this.wasActive = currentActive; try { this.getProxy().getGrid().postEvent(new MENetworkCellArrayUpdate()); this.getHost().markForUpdate(); } catch (final GridAccessException e) { // :P } } } @MENetworkEventSubscribe public void updateChannels(final MENetworkChannelsChanged changedChannels) { this.updateStatus(); } @Override protected int getUpgradeSlots() { return 5; } @Override public void updateSetting(final IConfigManager manager, final Settings settingName, final Enum newValue) { this.resetCache(true); this.getHost().markForSave(); } @Override public void onChangeInventory(final FixedItemInv inv, final int slot, final InvOperation mc, final ItemStack removedStack, final ItemStack newStack) { super.onChangeInventory(inv, slot, mc, removedStack, newStack); if (inv == this.Config) { this.resetCache(true); } } @Override public void upgradesChanged() { super.upgradesChanged(); this.resetCache(true); } @Override public void readFromNBT(final CompoundTag data) { super.readFromNBT(data); this.Config.readFromNBT(data, "config"); this.priority = data.getInt("priority"); } @Override public void writeToNBT(final CompoundTag data) { super.writeToNBT(data); this.Config.writeToNBT(data, "config"); data.putInt("priority", this.priority); } @Override public FixedItemInv getInventoryByName(final String name) { if (name.equals("config")) { return this.Config; } return super.getInventoryByName(name); } private void resetCache(final boolean fullReset) { if (this.getHost() == null || this.getHost().getTile() == null || this.getHost().getTile().getWorld() == null || this.getHost().getTile().getWorld().isClient) { return; } if (fullReset) { this.resetCacheLogic = 2; } else { this.resetCacheLogic = 1; } try { this.getProxy().getTick().alertDevice(this.getProxy().getNode()); } catch (final GridAccessException e) { // :P } } @Override public boolean isValid(final Object verificationToken) { return this.handler == verificationToken; } @Override public void postChange(final IBaseMonitor monitor, final Iterable change, final IActionSource source) { try { if (this.getProxy().isActive()) { this.getProxy().getStorage().postAlterationOfStoredItems( AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class), change, this.mySrc); } } catch (final GridAccessException e) { // :( } } @Override public void onListUpdate() { // not used here. } @Override public void getBoxes(final IPartCollisionHelper bch) { bch.addBox(3, 3, 15, 13, 13, 16); bch.addBox(2, 2, 14, 14, 14, 15); bch.addBox(5, 5, 12, 11, 11, 14); } @Override public void onNeighborChanged(BlockView w, BlockPos pos, BlockPos neighbor) { if (pos.offset(this.getSide().getFacing()).equals(neighbor)) { final BlockEntity te = w.getBlockEntity(neighbor); // In case the TE was destroyed, we have to do a full reset immediately. if (te == null) { this.resetCache(true); this.resetCache(); } else { this.resetCache(false); } } } @Override public float getCableConnectionLength(AECableType cable) { return 4; } @Override public boolean onPartActivate(final PlayerEntity player, final Hand hand, final Vec3d pos) { if (Platform.isServer()) { ContainerOpener.openContainer(StorageBusContainer.TYPE, player, ContainerLocator.forPart(this)); } return true; } @Override public TickingRequest getTickingRequest(final IGridNode node) { return new TickingRequest(TickRates.StorageBus.getMin(), TickRates.StorageBus.getMax(), this.monitor == null, true); } @Override public TickRateModulation tickingRequest(final IGridNode node, final int ticksSinceLastCall) { if (this.resetCacheLogic != 0) { this.resetCache(); } if (this.monitor != null) { return this.monitor.onTick(); } return TickRateModulation.SLEEP; } private void resetCache() { final boolean fullReset = this.resetCacheLogic == 2; this.resetCacheLogic = 0; final IMEInventory in = this.getInternalHandler(); IItemList before = AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class) .createList(); if (in != null) { before = in.getAvailableItems(before); } this.cached = false; if (fullReset) { this.handlerHash = 0; } final IMEInventory out = this.getInternalHandler(); if (in != out) { IItemList after = AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class) .createList(); if (out != null) { after = out.getAvailableItems(after); } Platform.postListChanges(before, after, this, this.mySrc); } } private IMEInventory getInventoryWrapper(BlockEntity target) { Direction targetSide = this.getSide().getFacing().getOpposite(); // Prioritize a handler to directly link to another ME network final LazyOptional accessorOpt = target .getCapability(Capabilities.STORAGE_MONITORABLE_ACCESSOR, targetSide); if (accessorOpt.isPresent()) { IStorageMonitorableAccessor accessor = accessorOpt.orElse(null); IStorageMonitorable inventory = accessor.getInventory(this.mySrc); if (inventory != null) { return inventory.getInventory(AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class)); } // So this could / can be a design decision. If the tile does support our custom // capability, // but it does not return an inventory for the action source, we do NOT fall // back to using // IItemHandler's, as that might circumvent the security setings, and might also // cause // performance issues. return null; } // Check via cap for IItemHandler final LazyOptional handlerExtOpt = target .getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, targetSide); if (handlerExtOpt.isPresent()) { return new ItemHandlerAdapter(handlerExtOpt.orElse(null), this); } return null; } // TODO, LazyOptionals are cacheable this might need changing? private int createHandlerHash(BlockEntity target) { if (target == null) { return 0; } final Direction targetSide = this.getSide().getFacing().getOpposite(); final LazyOptional accessorOpt = target .getCapability(Capabilities.STORAGE_MONITORABLE_ACCESSOR, targetSide); if (accessorOpt.isPresent()) { return Objects.hash(target, accessorOpt.orElse(null)); } final LazyOptional itemHandlerOpt = target .getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, targetSide); if (itemHandlerOpt.isPresent()) { FixedItemInv itemHandler = itemHandlerOpt.orElse(null); return Objects.hash(target, itemHandler, itemHandler.getSlotCount()); } return 0; } public MEInventoryHandler getInternalHandler() { if (this.cached) { return this.handler; } final boolean wasSleeping = this.monitor == null; this.cached = true; final BlockEntity self = this.getHost().getTile(); final BlockEntity target = self.getWorld().getBlockEntity(self.getPos().offset(this.getSide().getFacing())); final int newHandlerHash = this.createHandlerHash(target); if (newHandlerHash != 0 && newHandlerHash == this.handlerHash) { return this.handler; } this.handlerHash = newHandlerHash; this.handler = null; this.monitor = null; if (target != null) { IMEInventory inv = this.getInventoryWrapper(target); if (inv instanceof MEMonitorIInventory) { final MEMonitorIInventory h = (MEMonitorIInventory) inv; h.setMode((StorageFilter) this.getConfigManager().getSetting(Settings.STORAGE_FILTER)); } if (inv instanceof ITickingMonitor) { this.monitor = (ITickingMonitor) inv; this.monitor.setActionSource(new MachineSource(this)); } if (inv != null) { this.checkInterfaceVsStorageBus(target, this.getSide().getOpposite()); this.handler = new MEInventoryHandler(inv, AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class)); this.handler.setBaseAccess((AccessRestriction) this.getConfigManager().getSetting(Settings.ACCESS)); this.handler.setWhitelist(this.getInstalledUpgrades(Upgrades.INVERTER) > 0 ? IncludeExclude.BLACKLIST : IncludeExclude.WHITELIST); this.handler.setPriority(this.priority); final IItemList priorityList = AEApi.instance().storage() .getStorageChannel(IItemStorageChannel.class).createList(); final int slotsToUse = 18 + this.getInstalledUpgrades(Upgrades.CAPACITY) * 9; for (int x = 0; x < this.Config.getSlots() && x < slotsToUse; x++) { final IAEItemStack is = this.Config.getAEStackInSlot(x); if (is != null) { priorityList.add(is); } } if (this.getInstalledUpgrades(Upgrades.FUZZY) > 0) { this.handler.setPartitionList(new FuzzyPriorityList(priorityList, (FuzzyMode) this.getConfigManager().getSetting(Settings.FUZZY_MODE))); } else { this.handler.setPartitionList(new PrecisePriorityList(priorityList)); } if (inv instanceof IBaseMonitor) { ((IBaseMonitor) inv).addListener(this, this.handler); } } } // update sleep state... if (wasSleeping != (this.monitor == null)) { try { final ITickManager tm = this.getProxy().getTick(); if (this.monitor == null) { tm.sleepDevice(this.getProxy().getNode()); } else { tm.wakeDevice(this.getProxy().getNode()); } } catch (final GridAccessException e) { // :( } } try { // force grid to update handlers... this.getProxy().getGrid().postEvent(new MENetworkCellArrayUpdate()); } catch (final GridAccessException e) { // :3 } return this.handler; } private void checkInterfaceVsStorageBus(final BlockEntity target, final AEPartLocation side) { IInterfaceHost achievement = null; if (target instanceof IInterfaceHost) { achievement = (IInterfaceHost) target; } if (target instanceof IPartHost) { final Object part = ((IPartHost) target).getPart(side); if (part instanceof IInterfaceHost) { achievement = (IInterfaceHost) part; } } if (achievement != null && achievement.getActionableNode() != null) { // Platform.increaseStat( achievement.getActionableNode().getPlayerID(), // Achievements.Recursive.getAchievement() // ); // Platform.increaseStat( getActionableNode().getPlayerID(), // Achievements.Recursive.getAchievement() ); } } @Override public List getCellArray(final IStorageChannel channel) { if (channel == AEApi.instance().storage().getStorageChannel(IItemStorageChannel.class)) { final IMEInventoryHandler out = this.getProxy().isActive() ? this.getInternalHandler() : null; if (out != null) { return Collections.singletonList(out); } } return Collections.emptyList(); } @Override public int getPriority() { return this.priority; } @Override public void setPriority(final int newValue) { this.priority = newValue; this.getHost().markForSave(); this.resetCache(true); } @Override public void blinkCell(final int slot) { } // TODO: BC PIPE INTEGRATION /* * @Override * * @Method( iname = IntegrationType.BuildCraftTransport ) public ConnectOverride * overridePipeConnection( PipeType type, ForgeDirection with ) { return type == * PipeType.ITEM && with == this.getSide() ? ConnectOverride.CONNECT : * ConnectOverride.DISCONNECT; } */ @Override public void saveChanges(final ICellInventory cellInventory) { // nope! } @Override public IPartModel getStaticModels() { if (this.isActive() && this.isPowered()) { return MODELS_HAS_CHANNEL; } else if (this.isPowered()) { return MODELS_ON; } else { return MODELS_OFF; } } @Override public ItemStack getItemStackRepresentation() { return AEApi.instance().definitions().parts().storageBus().maybeStack(1).orElse(ItemStack.EMPTY); } @Override public ContainerType getContainerType() { return StorageBusContainer.TYPE; } }