Esempio n. 1
0
 private int secondarySort(int compareInt, IAEItemStack o1, IAEItemStack o2) {
   if (compareInt == 0) {
     return Platform.getItemDisplayName(o2)
         .compareToIgnoreCase(Platform.getItemDisplayName(o1));
   }
   return compareInt;
 }
  @Override
  public boolean onPartActivate(EntityPlayer p, Vec3 pos) {
    if (p.isSneaking()) {
      return false;
    }

    if (Platform.isServer()) {
      Platform.openGUI(p, this.getTileEntity(), this.side, GuiBridge.GUI_INTERFACE);
    }

    return true;
  }
 @Override
 public boolean isSlotEnabled(final int idx) {
   if (idx == 1) {
     return Platform.isServer()
         ? !this.getPatternTerminal().isCraftingRecipe()
         : !this.isCraftingMode();
   } else if (idx == 2) {
     return Platform.isServer()
         ? this.getPatternTerminal().isCraftingRecipe()
         : this.isCraftingMode();
   } else {
     return false;
   }
 }
  private void recalculatePlan() {
    this.reboot = true;

    if (this.forcePlan) {
      return;
    }

    final ItemStack is = this.inv.getStackInSlot(10);

    if (is != null && is.getItem() instanceof ItemEncodedPattern) {
      if (!Platform.isSameItem(is, this.myPattern)) {
        final World w = this.getWorldObj();
        final ItemEncodedPattern iep = (ItemEncodedPattern) is.getItem();
        final ICraftingPatternDetails ph = iep.getPatternForItem(is, w);

        if (ph != null && ph.isCraftable()) {
          this.progress = 0;
          this.myPattern = is;
          this.myPlan = ph;
        }
      }
    } else {
      this.progress = 0;
      this.forcePlan = false;
      this.myPlan = null;
      this.myPattern = null;
      this.pushDirection = ForgeDirection.UNKNOWN;
    }

    this.updateSleepiness();
  }
 @Override
 public IConfigManager getConfigManager() {
   if (Platform.isServer()) {
     return this.serverCM;
   }
   return this.clientCM;
 }
  @Override
  public void setInternal(IMEInventory<T> i) {
    if (this.monitor != null) {
      this.monitor.removeListener(this);
    }

    this.monitor = null;
    IItemList<T> before =
        this.getInternal() == null
            ? this.channel.createList()
            : this.getInternal()
                .getAvailableItems(new ItemListIgnoreCrafting(this.channel.createList()));

    super.setInternal(i);
    if (i instanceof IMEMonitor) {
      this.monitor = (IMEMonitor<T>) i;
    }

    IItemList<T> after =
        this.getInternal() == null
            ? this.channel.createList()
            : this.getInternal()
                .getAvailableItems(new ItemListIgnoreCrafting(this.channel.createList()));

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

    Platform.postListChanges(before, after, this, this.changeSource);
  }
 private void addToENet() {
   if (IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.IC2)) {
     IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance(IntegrationType.IC2);
     if (!this.isInIC2 && Platform.isServer() && ic2Integration != null) {
       ic2Integration.addToEnergyNet(this);
       this.isInIC2 = true;
     }
   }
 }
  @Override
  public void invalidate() {
    if (Platform.isClient()) {
      return;
    }

    AELog.info("Released Ticket " + this.ct.toString());
    ForgeChunkManager.releaseTicket(this.ct);
  }
 private void removeFromENet() {
   if (IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.IC2)) {
     IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance(IntegrationType.IC2);
     if (this.isInIC2 && Platform.isServer() && ic2Integration != null) {
       ic2Integration.removeFromEnergyNet(this);
       this.isInIC2 = false;
     }
   }
 }
 @Override
 public void securityBreak() {
   if (this.is.stackSize > 0) {
     List<ItemStack> items = new ArrayList<ItemStack>();
     items.add(this.is.copy());
     this.host.removePart(this.side, false);
     Platform.spawnDrops(
         this.tile.getWorldObj(), this.tile.xCoord, this.tile.yCoord, this.tile.zCoord, items);
     this.is.stackSize = 0;
   }
 }
  @Override
  public void detectAndSendChanges() {
    super.detectAndSendChanges();
    if (Platform.isServer()) {
      if (this.isCraftingMode() != this.getPatternTerminal().isCraftingRecipe()) {
        this.setCraftingMode(this.getPatternTerminal().isCraftingRecipe());
        this.updateOrderOfOutputSlots();
      }

      this.substitute = this.patternTerminal.isSubstitution();
    }
  }
  @Override
  public void detectAndSendChanges() {
    this.verifyPermissions(SecurityPermissions.BUILD, false);

    if (Platform.isServer()) {
      this.rsMode =
          (RedstoneMode)
              this.upgradeable.getConfigManager().getSetting(Settings.REDSTONE_CONTROLLED);
    }

    this.craftProgress = this.tma.getCraftingProgress();

    this.standardDetectAndSendChanges();
  }
 @Override
 public ItemStack getDisplayStack() {
   if (Platform.isClient()) {
     final ItemStack is = super.getStack();
     if (is != null && is.getItem() instanceof ItemEncodedPattern) {
       final ItemEncodedPattern iep = (ItemEncodedPattern) is.getItem();
       final ItemStack out = iep.getOutput(is);
       if (out != null) {
         return out;
       }
     }
   }
   return super.getStack();
 }
  @Override
  public void detectAndSendChanges() {
    super.detectAndSendChanges();

    if (!this.wirelessTerminalGUIObject.rangeCheck()) {
      if (Platform.isServer() && this.isContainerValid) {
        this.getPlayerInv().player.addChatMessage(PlayerMessages.OutOfRange.get());
      }

      this.isContainerValid = false;
    } else {
      this.powerMultiplier =
          AEConfig.instance.wireless_getDrainRate(this.wirelessTerminalGUIObject.getRange());
    }
  }
  @Override
  public void onSlotChange(final Slot s) {
    if (s == this.patternSlotOUT && Platform.isServer()) {
      for (final Object crafter : this.crafters) {
        final ICrafting icrafting = (ICrafting) crafter;

        for (final Object g : this.inventorySlots) {
          if (g instanceof OptionalSlotFake || g instanceof SlotFakeCraftingMatrix) {
            final Slot sri = (Slot) g;
            icrafting.sendSlotContents(this, sri.slotNumber, sri.getStack());
          }
        }
        ((EntityPlayerMP) icrafting).isChangingQuantityOnly = false;
      }
      this.detectAndSendChanges();
    }
  }
  void initTicket() {
    if (Platform.isClient()) {
      return;
    }

    this.ct = ForgeChunkManager.requestTicket(AppEng.instance(), this.worldObj, Type.NORMAL);

    if (this.ct == null) {
      MinecraftServer server = FMLCommonHandler.instance().getMinecraftServerInstance();
      if (server != null) {
        List<EntityPlayerMP> pl = server.getConfigurationManager().playerEntityList;
        for (EntityPlayerMP p : pl) {
          p.addChatMessage(new ChatComponentText("Can't chunk load.."));
        }
      }
      return;
    }

    AELog.info("New Ticket " + this.ct.toString());
    ForgeChunkManager.forceChunk(
        this.ct, new ChunkCoordIntPair(this.xCoord >> 4, this.zCoord >> 4));
  }
  @Override
  @SideOnly(Side.CLIENT)
  public void addCheckedInformation(
      ItemStack itemStack, EntityPlayer player, List<String> toolTip, boolean advancedTooltips) {
    final NBTTagCompound tag = itemStack.getTagCompound();
    double internalCurrentPower = 0;
    double internalMaxPower = this.getMaxEnergyCapacity();

    if (tag != null) {
      internalCurrentPower = tag.getDouble("internalCurrentPower");
    }

    final double percent = internalCurrentPower / internalMaxPower;

    toolTip.add(
        GuiText.StoredEnergy.getLocal()
            + ':'
            + MessageFormat.format(" {0,number,#} ", internalCurrentPower)
            + Platform.gui_localize(PowerUnits.AE.unlocalizedName)
            + " - "
            + MessageFormat.format(" {0,number,#.##%} ", percent));
  }
  public void queueInventory(final ICrafting c) {
    if (Platform.isServer() && c instanceof EntityPlayer && this.monitor != null) {
      try {
        PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();
        final IItemList<IAEItemStack> monitorCache = this.monitor.getStorageList();

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

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

        NetworkHandler.instance.sendTo(piu, (EntityPlayerMP) c);
      } catch (final IOException e) {
        AELog.error(e);
      }
    }
  }
  public void craftOrGetItem(final PacketPatternSlot packetPatternSlot) {
    if (packetPatternSlot.slotItem != null && this.getCellInventory() != null) {
      final IAEItemStack out = packetPatternSlot.slotItem.copy();
      InventoryAdaptor inv = new AdaptorPlayerHand(this.getPlayerInv().player);
      final InventoryAdaptor playerInv =
          InventoryAdaptor.getAdaptor(this.getPlayerInv().player, ForgeDirection.UNKNOWN);

      if (packetPatternSlot.shift) {
        inv = playerInv;
      }

      if (inv.simulateAdd(out.getItemStack()) != null) {
        return;
      }

      final IAEItemStack extracted =
          Platform.poweredExtraction(
              this.getPowerSource(), this.getCellInventory(), out, this.getActionSource());
      final EntityPlayer p = this.getPlayerInv().player;

      if (extracted != null) {
        inv.addItems(extracted.getItemStack());
        if (p instanceof EntityPlayerMP) {
          this.updateHeld((EntityPlayerMP) p);
        }
        this.detectAndSendChanges();
        return;
      }

      final InventoryCrafting ic = new InventoryCrafting(new ContainerNull(), 3, 3);
      final InventoryCrafting real = new InventoryCrafting(new ContainerNull(), 3, 3);

      for (int x = 0; x < 9; x++) {
        ic.setInventorySlotContents(
            x,
            packetPatternSlot.pattern[x] == null
                ? null
                : packetPatternSlot.pattern[x].getItemStack());
      }

      final IRecipe r = Platform.findMatchingRecipe(ic, p.worldObj);

      if (r == null) {
        return;
      }

      final IMEMonitor<IAEItemStack> storage = this.getPatternTerminal().getItemInventory();
      final IItemList<IAEItemStack> all = storage.getStorageList();

      final ItemStack is = r.getCraftingResult(ic);

      for (int x = 0; x < ic.getSizeInventory(); x++) {
        if (ic.getStackInSlot(x) != null) {
          final ItemStack pulled =
              Platform.extractItemsByRecipe(
                  this.getPowerSource(),
                  this.getActionSource(),
                  storage,
                  p.worldObj,
                  r,
                  is,
                  ic,
                  ic.getStackInSlot(x),
                  x,
                  all,
                  Actionable.MODULATE,
                  ItemViewCell.createFilter(this.getViewCells()));
          real.setInventorySlotContents(x, pulled);
        }
      }

      final IRecipe rr = Platform.findMatchingRecipe(real, p.worldObj);

      if (rr == r && Platform.isSameItemPrecise(rr.getCraftingResult(real), is)) {
        final SlotCrafting sc = new SlotCrafting(p, real, this.cOut, 0, 0, 0);
        sc.onPickupFromSlot(p, is);

        for (int x = 0; x < real.getSizeInventory(); x++) {
          final ItemStack failed = playerInv.addItems(real.getStackInSlot(x));

          if (failed != null) {
            p.dropPlayerItemWithRandomChoice(failed, false);
          }
        }

        inv.addItems(is);
        if (p instanceof EntityPlayerMP) {
          this.updateHeld((EntityPlayerMP) p);
        }
        this.detectAndSendChanges();
      } else {
        for (int x = 0; x < real.getSizeInventory(); x++) {
          final ItemStack failed = real.getStackInSlot(x);
          if (failed != null) {
            this.getCellInventory()
                .injectItems(
                    AEItemStack.create(failed),
                    Actionable.MODULATE,
                    new MachineSource(this.getPatternTerminal()));
          }
        }
      }
    }
  }
 @Override
 public void fillWithRain(final World w, final int x, final int y, final int z) {
   if (Platform.isServer()) {
     w.setBlock(x, y, z, Platform.AIR_BLOCK, 0, 3);
   }
 }
  protected ContainerMEMonitorable(
      final InventoryPlayer ip, final ITerminalHost monitorable, final boolean bindInventory) {
    super(
        ip,
        monitorable instanceof TileEntity ? (TileEntity) monitorable : null,
        monitorable instanceof IPart ? (IPart) monitorable : null);

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

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

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

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

        this.cellInv = this.monitor;

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

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

    if (bindInventory) {
      this.bindPlayerInventory(ip, 0, 0);
    }
  }
 private void setInternal(ItemStack is, double amt) {
   final NBTTagCompound nbt = Platform.openNbtData(is);
   nbt.setDouble("internalCurrentPower", amt);
 }
  @Override
  public void detectAndSendChanges() {
    if (Platform.isServer()) {
      if (this.monitor != this.host.getItemInventory()) {
        this.isContainerValid = false;
      }

      for (final Settings set : this.serverCM.getSettings()) {
        final Enum<?> sideLocal = this.serverCM.getSetting(set);
        final Enum<?> sideRemote = this.clientCM.getSetting(set);

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

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

          final PacketMEInventoryUpdate piu = new PacketMEInventoryUpdate();

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

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

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

      this.updatePowerStatus();

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

      super.detectAndSendChanges();
    }
  }
 @Override
 public void markDirty() {
   this.writeToNBT(Platform.openNbtData(this.is), "upgrades");
 }
 public CellUpgrades(final ItemStack is, final int upgrades) {
   super(is, null, upgrades);
   this.is = is;
   this.readFromNBT(Platform.openNbtData(is), "upgrades");
 }
 private double getInternal(ItemStack is) {
   final NBTTagCompound nbt = Platform.openNbtData(is);
   return nbt.getDouble("internalCurrentPower");
 }
  @Override
  public TickRateModulation tickingRequest(final IGridNode node, int ticksSinceLastCall) {
    if (this.inv.getStackInSlot(9) != null) {
      this.pushOut(this.inv.getStackInSlot(9));

      // did it eject?
      if (this.inv.getStackInSlot(9) == null) {
        this.markDirty();
      }

      this.ejectHeldItems();
      this.updateSleepiness();
      this.progress = 0;
      return this.isAwake ? TickRateModulation.IDLE : TickRateModulation.SLEEP;
    }

    if (this.myPlan == null) {
      this.updateSleepiness();
      return TickRateModulation.SLEEP;
    }

    if (this.reboot) {
      ticksSinceLastCall = 1;
    }

    if (!this.isAwake) {
      return TickRateModulation.SLEEP;
    }

    this.reboot = false;
    int speed = 10;
    switch (this.upgrades.getInstalledUpgrades(Upgrades.SPEED)) {
      case 0:
        this.progress += this.userPower(ticksSinceLastCall, speed = 10, 1.0);
        break;
      case 1:
        this.progress += this.userPower(ticksSinceLastCall, speed = 13, 1.3);
        break;
      case 2:
        this.progress += this.userPower(ticksSinceLastCall, speed = 17, 1.7);
        break;
      case 3:
        this.progress += this.userPower(ticksSinceLastCall, speed = 20, 2.0);
        break;
      case 4:
        this.progress += this.userPower(ticksSinceLastCall, speed = 25, 2.5);
        break;
      case 5:
        this.progress += this.userPower(ticksSinceLastCall, speed = 50, 5.0);
        break;
    }

    if (this.progress >= 100) {
      for (int x = 0; x < this.craftingInv.getSizeInventory(); x++) {
        this.craftingInv.setInventorySlotContents(x, this.inv.getStackInSlot(x));
      }

      this.progress = 0;
      final ItemStack output = this.myPlan.getOutput(this.craftingInv, this.getWorldObj());
      if (output != null) {
        FMLCommonHandler.instance()
            .firePlayerCraftingEvent(
                Platform.getPlayer((WorldServer) this.getWorldObj()), output, this.craftingInv);

        this.pushOut(output.copy());

        for (int x = 0; x < this.craftingInv.getSizeInventory(); x++) {
          this.inv.setInventorySlotContents(
              x, Platform.getContainerItem(this.craftingInv.getStackInSlot(x)));
        }

        if (this.inv.getStackInSlot(10) == null) {
          this.forcePlan = false;
          this.myPlan = null;
          this.pushDirection = ForgeDirection.UNKNOWN;
        }

        this.ejectHeldItems();

        try {
          final TargetPoint where =
              new TargetPoint(
                  this.worldObj.provider.dimensionId, this.xCoord, this.yCoord, this.zCoord, 32);
          final IAEItemStack item = AEItemStack.create(output);
          NetworkHandler.instance.sendToAllAround(
              new PacketAssemblerAnimation(
                  this.xCoord, this.yCoord, this.zCoord, (byte) speed, item),
              where);
        } catch (final IOException e) {
          // ;P
        }

        this.markDirty();
        this.updateSleepiness();
        return this.isAwake ? TickRateModulation.IDLE : TickRateModulation.SLEEP;
      }
    }

    return TickRateModulation.FASTER;
  }
  @Override
  public void serverPacketData(INetworkInfo manager, AppEngPacket packet, EntityPlayer player) {
    EntityPlayerMP pmp = (EntityPlayerMP) player;
    Container con = pmp.openContainer;

    if (con instanceof IContainerCraftingPacket) {
      IContainerCraftingPacket cct = (IContainerCraftingPacket) con;
      IGridNode node = cct.getNetworkNode();
      if (node != null) {
        IGrid grid = node.getGrid();
        if (grid == null) {
          return;
        }

        IStorageGrid inv = grid.getCache(IStorageGrid.class);
        IEnergyGrid energy = grid.getCache(IEnergyGrid.class);
        ISecurityGrid security = grid.getCache(ISecurityGrid.class);
        IInventory craftMatrix = cct.getInventoryByName("crafting");
        IInventory playerInventory = cct.getInventoryByName("player");

        Actionable realForFake = cct.useRealItems() ? Actionable.MODULATE : Actionable.SIMULATE;

        if (inv != null && this.recipe != null && security != null) {
          InventoryCrafting testInv = new InventoryCrafting(new ContainerNull(), 3, 3);
          for (int x = 0; x < 9; x++) {
            if (this.recipe[x] != null && this.recipe[x].length > 0) {
              testInv.setInventorySlotContents(x, this.recipe[x][0]);
            }
          }

          IRecipe r = Platform.findMatchingRecipe(testInv, pmp.worldObj);

          if (r != null && security.hasPermission(player, SecurityPermissions.EXTRACT)) {
            ItemStack is = r.getCraftingResult(testInv);

            if (is != null) {
              IMEMonitor<IAEItemStack> storage = inv.getItemInventory();
              IItemList all = storage.getStorageList();
              IPartitionList<IAEItemStack> filter = ItemViewCell.createFilter(cct.getViewCells());

              for (int x = 0; x < craftMatrix.getSizeInventory(); x++) {
                ItemStack patternItem = testInv.getStackInSlot(x);

                ItemStack currentItem = craftMatrix.getStackInSlot(x);
                if (currentItem != null) {
                  testInv.setInventorySlotContents(x, currentItem);
                  ItemStack newItemStack =
                      r.matches(testInv, pmp.worldObj) ? r.getCraftingResult(testInv) : null;
                  testInv.setInventorySlotContents(x, patternItem);

                  if (newItemStack == null || !Platform.isSameItemPrecise(newItemStack, is)) {
                    IAEItemStack in = AEItemStack.create(currentItem);
                    if (in != null) {
                      IAEItemStack out =
                          realForFake == Actionable.SIMULATE
                              ? null
                              : Platform.poweredInsert(energy, storage, in, cct.getSource());
                      if (out != null) {
                        craftMatrix.setInventorySlotContents(x, out.getItemStack());
                      } else {
                        craftMatrix.setInventorySlotContents(x, null);
                      }

                      currentItem = craftMatrix.getStackInSlot(x);
                    }
                  }
                }

                // True if we need to fetch an item for the recipe
                if (patternItem != null && currentItem == null) {
                  // Grab from network by recipe
                  ItemStack whichItem =
                      Platform.extractItemsByRecipe(
                          energy,
                          cct.getSource(),
                          storage,
                          player.worldObj,
                          r,
                          is,
                          testInv,
                          patternItem,
                          x,
                          all,
                          realForFake,
                          filter);

                  // If that doesn't get it, grab exact items from network (?)
                  // TODO see if this code is necessary
                  if (whichItem == null) {
                    for (int y = 0; y < this.recipe[x].length; y++) {
                      IAEItemStack request = AEItemStack.create(this.recipe[x][y]);
                      if (request != null) {
                        if (filter == null || filter.isListed(request)) {
                          request.setStackSize(1);
                          IAEItemStack out =
                              Platform.poweredExtraction(energy, storage, request, cct.getSource());
                          if (out != null) {
                            whichItem = out.getItemStack();
                            break;
                          }
                        }
                      }
                    }
                  }

                  // If that doesn't work, grab from the player's inventory
                  if (whichItem == null && playerInventory != null) {
                    whichItem = extractItemFromPlayerInventory(player, realForFake, patternItem);
                  }

                  craftMatrix.setInventorySlotContents(x, whichItem);
                }
              }
              con.onCraftMatrixChanged(craftMatrix);
            }
          }
        }
      }
    }
  }