Package appeng.container.implementations

Source Code of appeng.container.implementations.ContainerMEMonitorable

package appeng.container.implementations;

import java.io.IOException;
import java.nio.BufferOverflowException;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ICrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import appeng.api.AEApi;
import appeng.api.config.Actionable;
import appeng.api.config.PowerMultiplier;
import appeng.api.config.SecurityPermissions;
import appeng.api.config.Settings;
import appeng.api.config.SortDir;
import appeng.api.config.SortOrder;
import appeng.api.config.ViewItems;
import appeng.api.implementations.guiobjects.IPortableCell;
import appeng.api.implementations.tiles.IMEChest;
import appeng.api.implementations.tiles.IViewCellStorage;
import appeng.api.networking.IGrid;
import appeng.api.networking.IGridHost;
import appeng.api.networking.IGridNode;
import appeng.api.networking.energy.IEnergyGrid;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.networking.storage.IBaseMonitor;
import appeng.api.parts.IPart;
import appeng.api.storage.IMEMonitor;
import appeng.api.storage.IMEMonitorHandlerReceiver;
import appeng.api.storage.ITerminalHost;
import appeng.api.storage.data.IAEItemStack;
import appeng.api.storage.data.IItemList;
import appeng.api.util.IConfigManager;
import appeng.api.util.IConfigurableObject;
import appeng.container.AEBaseContainer;
import appeng.container.guisync.GuiSync;
import appeng.container.slot.SlotRestrictedInput;
import appeng.core.AELog;
import appeng.core.sync.network.NetworkHandler;
import appeng.core.sync.packets.PacketMEInventoryUpdate;
import appeng.core.sync.packets.PacketValueConfig;
import appeng.me.helpers.ChannelPowerSrc;
import appeng.util.ConfigManager;
import appeng.util.IConfigManagerHost;
import appeng.util.Platform;

public class ContainerMEMonitorable extends AEBaseContainer implements IConfigManagerHost, IConfigurableObject, IMEMonitorHandlerReceiver<IAEItemStack>
{

  final IMEMonitor<IAEItemStack> monitor;
  final IItemList<IAEItemStack> items = AEApi.instance().storage().createItemList();

  IConfigManager serverCM;
  final IConfigManager clientCM;

  @GuiSync(99)
  public boolean canAccessViewCells = false;

  @GuiSync(98)
  public boolean hasPower = false;

  public final SlotRestrictedInput[] cellView = new SlotRestrictedInput[5];

  public IConfigManagerHost gui;
  private IGridNode networkNode;
  private final ITerminalHost host;

  public IGridNode getNetworkNode()
  {
    return networkNode;
  }

  protected ContainerMEMonitorable(InventoryPlayer ip, ITerminalHost monitorable, boolean bindInventory) {
    super( ip, monitorable instanceof TileEntity ? (TileEntity) monitorable : null, monitorable instanceof IPart ? (IPart) monitorable : null );

    host = monitorable;
    clientCM = new ConfigManager( this );

    clientCM.registerSetting( Settings.SORT_BY, SortOrder.NAME );
    clientCM.registerSetting( Settings.VIEW_MODE, ViewItems.ALL );
    clientCM.registerSetting( Settings.SORT_DIRECTION, SortDir.ASCENDING );

    if ( Platform.isServer() )
    {
      serverCM = monitorable.getConfigManager();

      monitor = monitorable.getItemInventory();
      if ( monitor != null )
      {
        monitor.addListener( this, null );

        cellInv = monitor;

        if ( monitorable instanceof IPortableCell )
          powerSrc = (IPortableCell) monitorable;
        else if ( monitorable instanceof IMEChest )
          powerSrc = (IMEChest) monitorable;
        else if ( monitorable instanceof IGridHost )
        {
          IGridNode node = ((IGridHost) monitorable).getGridNode( ForgeDirection.UNKNOWN );
          if ( node != null )
          {
            networkNode = node;
            IGrid g = node.getGrid();
            if ( g != null )
              powerSrc = new ChannelPowerSrc( networkNode, (IEnergyGrid) g.getCache( IEnergyGrid.class ) );
          }
        }
      }
      else
        isContainerValid = false;
    }
    else
      monitor = null;

    canAccessViewCells = false;
    if ( monitorable instanceof IViewCellStorage )
    {
      for (int y = 0; y < 5; y++)
      {
        cellView[y] = new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.VIEW_CELL, ((IViewCellStorage) monitorable).getViewCellStorage(), y, 206, y * 18 + 8,
            invPlayer );
        cellView[y].allowEdit = canAccessViewCells;
        addSlotToContainer( cellView[y] );
      }
    }

    if ( bindInventory )
      bindPlayerInventory( ip, 0, 0 );
  }

  public ContainerMEMonitorable(InventoryPlayer ip, ITerminalHost monitorable) {
    this( ip, monitorable, true );
  }

  @Override
  public void detectAndSendChanges()
  {
    if ( Platform.isServer() )
    {
      if ( monitor != host.getItemInventory() )
        isContainerValid = false;
     
      for (Enum set : serverCM.getSettings())
      {
        Enum sideLocal = serverCM.getSetting( set );
        Enum sideRemote = clientCM.getSetting( set );

        if ( sideLocal != sideRemote )
        {
          clientCM.putSetting( set, sideLocal );
          for (Object crafter : this.crafters)
          {
            try
            {
              NetworkHandler.instance.sendTo( new PacketValueConfig( set.name(), sideLocal.name() ), (EntityPlayerMP) crafter );
            }
            catch (IOException e)
            {
              AELog.error( e );
            }
          }
        }
      }

      if ( !items.isEmpty() )
      {
        try
        {
          IItemList<IAEItemStack> monitorCache = monitor.getStorageList();

          PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();

          for (IAEItemStack is : items)
          {
            IAEItemStack send = monitorCache.findPrecise( is );
            if ( send == null )
            {
              is.setStackSize( 0 );
              piu.appendItem( is );
            }
            else
              piu.appendItem( send );
          }

          if ( !piu.isEmpty() )
          {
            items.resetStatus();

            for (Object c : this.crafters)
            {
              if ( c instanceof EntityPlayer )
                NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );
            }
          }
        }
        catch (IOException e)
        {
          AELog.error( e );
        }
      }

      updatePowerStatus();

      boolean oldCanAccessViewCells = canAccessViewCells;
      canAccessViewCells = hasAccess( SecurityPermissions.BUILD, false );
      if ( canAccessViewCells != oldCanAccessViewCells )
      {
        for (int y = 0; y < 5; y++)
        {
          if ( cellView[y] != null )
            cellView[y].allowEdit = canAccessViewCells;
        }
      }

      super.detectAndSendChanges();
    }
  }

  protected void updatePowerStatus()
  {
    try
    {
      if ( networkNode != null )
        hasPower = networkNode.isActive();
      else if ( powerSrc instanceof IEnergyGrid )
        hasPower = ((IEnergyGrid) powerSrc).isNetworkPowered();
      else
        hasPower = powerSrc.extractAEPower( 1, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > 0.8;
    }
    catch (Throwable t)
    {
      // :P
    }
  }

  @Override
  public void addCraftingToCrafters(ICrafting c)
  {
    super.addCraftingToCrafters( c );
    queueInventory( c );
  }

  public void queueInventory(ICrafting c)
  {
    if ( Platform.isServer() && c instanceof EntityPlayer && monitor != null )
    {
      try
      {
        PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();
        IItemList<IAEItemStack> monitorCache = monitor.getStorageList();

        for (IAEItemStack send : monitorCache)
        {
          try
          {
            piu.appendItem( send );
          }
          catch (BufferOverflowException boe)
          {
            NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );

            piu = new PacketMEInventoryUpdate();
            piu.appendItem( send );
          }
        }

        NetworkHandler.instance.sendTo( piu, (EntityPlayerMP) c );
      }
      catch (IOException e)
      {
        AELog.error( e );
      }

    }
  }

  @Override
  public void onListUpdate()
  {
    for (Object c : this.crafters)
    {
      if ( c instanceof ICrafting )
      {
        ICrafting cr = (ICrafting) c;
        queueInventory( cr );
      }
    }
  }

  @Override
  public void onUpdate(String field, Object oldValue, Object newValue)
  {
    if ( field.equals( "canAccessViewCells" ) )
    {
      for (int y = 0; y < 5; y++)
        if ( cellView[y] != null )
          cellView[y].allowEdit = canAccessViewCells;
    }

    super.onUpdate( field, oldValue, newValue );
  }

  @Override
  public void onContainerClosed(EntityPlayer player)
  {
    super.onContainerClosed( player );
    if ( monitor != null )
      monitor.removeListener( this );
  }

  @Override
  public void removeCraftingFromCrafters(ICrafting c)
  {
    super.removeCraftingFromCrafters( c );

    if ( this.crafters.isEmpty() && monitor != null )
      monitor.removeListener( this );
  }

  @Override
  public void postChange(IBaseMonitor<IAEItemStack> monitor, Iterable<IAEItemStack> change, BaseActionSource source)
  {
    for (IAEItemStack is : change)
      items.add( is );
  }

  @Override
  public boolean isValid(Object verificationToken)
  {
    return true;
  }

  @Override
  public void updateSetting(IConfigManager manager, Enum settingName, Enum newValue)
  {
    if ( gui != null )
      gui.updateSetting( manager, settingName, newValue );
  }

  @Override
  public IConfigManager getConfigManager()
  {
    if ( Platform.isServer() )
      return serverCM;
    return clientCM;
  }

  public ItemStack[] getViewCells()
  {
    ItemStack[] list = new ItemStack[cellView.length];

    for (int x = 0; x < cellView.length; x++)
      list[x] = cellView[x].getStack();

    return list;
  }
}
TOP

Related Classes of appeng.container.implementations.ContainerMEMonitorable

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.