yueh
662dbca3e1
* Fixes #4508: Correctly construct the sparse lists. Also renamed all uncondensed getters to sparse and all condensed to the simple ones. * Apply suggestions from code review Co-authored-by: shartte <shartte@users.noreply.github.com> * Streamlined collapsing the sparse lists * Extracted helper to condense stacks * Sort lists desc by stack size Co-authored-by: shartte <shartte@users.noreply.github.com>
281 lines
10 KiB
Java
281 lines
10 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, 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 <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.crafting;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import net.minecraft.inventory.CraftingInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.world.World;
|
|
import net.minecraft.world.server.ServerWorld;
|
|
import net.minecraftforge.fml.hooks.BasicEventHooks;
|
|
|
|
import appeng.api.config.Actionable;
|
|
import appeng.api.networking.crafting.ICraftingGrid;
|
|
import appeng.api.networking.crafting.ICraftingPatternDetails;
|
|
import appeng.api.networking.security.IActionSource;
|
|
import appeng.api.storage.channels.IItemStorageChannel;
|
|
import appeng.api.storage.data.IAEItemStack;
|
|
import appeng.api.storage.data.IItemList;
|
|
import appeng.container.ContainerNull;
|
|
import appeng.core.Api;
|
|
import appeng.me.cluster.implementations.CraftingCPUCluster;
|
|
import appeng.util.Platform;
|
|
|
|
public class CraftingTreeProcess {
|
|
|
|
private final CraftingTreeNode parent;
|
|
final ICraftingPatternDetails details;
|
|
private final CraftingJob job;
|
|
private final Map<CraftingTreeNode, Long> nodes = new HashMap<>();
|
|
private final int depth;
|
|
boolean possible = true;
|
|
private World world;
|
|
private long crafts = 0;
|
|
private boolean containerItems;
|
|
private boolean limitQty;
|
|
private boolean fullSimulation;
|
|
private long bytes = 0;
|
|
|
|
public CraftingTreeProcess(final ICraftingGrid cc, final CraftingJob job, final ICraftingPatternDetails details,
|
|
final CraftingTreeNode craftingTreeNode, final int depth) {
|
|
this.parent = craftingTreeNode;
|
|
this.details = details;
|
|
this.job = job;
|
|
this.depth = depth;
|
|
final World world = job.getWorld();
|
|
|
|
if (details.isCraftable()) {
|
|
final IAEItemStack[] list = details.getSparseInputs();
|
|
|
|
final CraftingInventory ic = new CraftingInventory(new ContainerNull(), 3, 3);
|
|
final IAEItemStack[] is = details.getSparseInputs();
|
|
for (int x = 0; x < ic.getSizeInventory(); x++) {
|
|
ic.setInventorySlotContents(x, is[x] == null ? ItemStack.EMPTY : is[x].createItemStack());
|
|
}
|
|
|
|
BasicEventHooks.firePlayerCraftingEvent(Platform.getPlayer((ServerWorld) world),
|
|
details.getOutput(ic, world), ic);
|
|
|
|
for (int x = 0; x < ic.getSizeInventory(); x++) {
|
|
final ItemStack g = ic.getStackInSlot(x);
|
|
if (!g.isEmpty() && g.getCount() > 1) {
|
|
this.fullSimulation = true;
|
|
}
|
|
}
|
|
|
|
for (final IAEItemStack part : details.getInputs()) {
|
|
final ItemStack g = part.createItemStack();
|
|
|
|
boolean isAnInput = false;
|
|
for (final IAEItemStack a : details.getOutputs()) {
|
|
if (!g.isEmpty() && a != null && a.equals(g)) {
|
|
isAnInput = true;
|
|
}
|
|
}
|
|
|
|
if (isAnInput) {
|
|
this.limitQty = true;
|
|
}
|
|
|
|
if (g.getItem().hasContainerItem(g)) {
|
|
this.limitQty = this.containerItems = true;
|
|
}
|
|
}
|
|
|
|
final boolean complicated = false;
|
|
|
|
if (this.containerItems || complicated) {
|
|
for (int x = 0; x < list.length; x++) {
|
|
final IAEItemStack part = list[x];
|
|
if (part != null) {
|
|
this.nodes.put(new CraftingTreeNode(cc, job, part.copy(), this, x, depth + 1),
|
|
part.getStackSize());
|
|
}
|
|
}
|
|
} else {
|
|
// this is minor different then below, this slot uses the pattern, but kinda
|
|
// fudges it.
|
|
for (final IAEItemStack part : details.getInputs()) {
|
|
for (int x = 0; x < list.length; x++) {
|
|
final IAEItemStack comparePart = list[x];
|
|
if (part != null && part.equals(comparePart)) {
|
|
// use the first slot...
|
|
this.nodes.put(new CraftingTreeNode(cc, job, part.copy(), this, x, depth + 1),
|
|
part.getStackSize());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (final IAEItemStack part : details.getInputs()) {
|
|
final ItemStack g = part.createItemStack();
|
|
|
|
boolean isAnInput = false;
|
|
for (final IAEItemStack a : details.getOutputs()) {
|
|
if (!g.isEmpty() && a != null && a.equals(g)) {
|
|
isAnInput = true;
|
|
}
|
|
}
|
|
|
|
if (isAnInput) {
|
|
this.limitQty = true;
|
|
}
|
|
}
|
|
|
|
for (final IAEItemStack part : details.getInputs()) {
|
|
this.nodes.put(new CraftingTreeNode(cc, job, part.copy(), this, -1, depth + 1), part.getStackSize());
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean notRecursive(final ICraftingPatternDetails details) {
|
|
return this.parent == null || this.parent.notRecursive(details);
|
|
}
|
|
|
|
long getTimes(final long remaining, final long stackSize) {
|
|
if (this.limitQty || this.fullSimulation) {
|
|
return 1;
|
|
}
|
|
return (remaining / stackSize) + (remaining % stackSize != 0 ? 1 : 0);
|
|
}
|
|
|
|
void request(final MECraftingInventory inv, final long i, final IActionSource src)
|
|
throws CraftBranchFailure, InterruptedException {
|
|
this.job.handlePausing();
|
|
|
|
if (this.fullSimulation) {
|
|
final CraftingInventory ic = new CraftingInventory(new ContainerNull(), 3, 3);
|
|
|
|
for (final Entry<CraftingTreeNode, Long> entry : this.nodes.entrySet()) {
|
|
final IAEItemStack item = entry.getKey().getStack(entry.getValue());
|
|
final IAEItemStack stack = entry.getKey().request(inv, item.getStackSize(), src);
|
|
|
|
ic.setInventorySlotContents(entry.getKey().getSlot(), stack.createItemStack());
|
|
}
|
|
|
|
BasicEventHooks.firePlayerCraftingEvent(Platform.getPlayer((ServerWorld) this.world),
|
|
this.details.getOutput(ic, this.world), ic);
|
|
|
|
for (int x = 0; x < ic.getSizeInventory(); x++) {
|
|
ItemStack is = ic.getStackInSlot(x);
|
|
is = Platform.getContainerItem(is);
|
|
|
|
final IAEItemStack o = Api.instance().storage().getStorageChannel(IItemStorageChannel.class)
|
|
.createStack(is);
|
|
if (o != null) {
|
|
this.bytes++;
|
|
inv.injectItems(o, Actionable.MODULATE, src);
|
|
}
|
|
}
|
|
} else {
|
|
// request and remove inputs...
|
|
for (final Entry<CraftingTreeNode, Long> entry : this.nodes.entrySet()) {
|
|
final IAEItemStack item = entry.getKey().getStack(entry.getValue());
|
|
final IAEItemStack stack = entry.getKey().request(inv, item.getStackSize() * i, src);
|
|
|
|
if (this.containerItems) {
|
|
final ItemStack is = Platform.getContainerItem(stack.createItemStack());
|
|
final IAEItemStack o = Api.instance().storage().getStorageChannel(IItemStorageChannel.class)
|
|
.createStack(is);
|
|
if (o != null) {
|
|
this.bytes++;
|
|
inv.injectItems(o, Actionable.MODULATE, src);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// assume its possible.
|
|
|
|
// add crafting results..
|
|
for (final IAEItemStack out : this.details.getOutputs()) {
|
|
final IAEItemStack o = out.copy();
|
|
o.setStackSize(o.getStackSize() * i);
|
|
inv.injectItems(o, Actionable.MODULATE, src);
|
|
}
|
|
|
|
this.crafts += i;
|
|
}
|
|
|
|
void dive(final CraftingJob job) {
|
|
job.addTask(this.getAmountCrafted(this.parent.getStack(1)), this.crafts, this.details, this.depth);
|
|
for (final CraftingTreeNode pro : this.nodes.keySet()) {
|
|
pro.dive(job);
|
|
}
|
|
|
|
job.addBytes(8 + this.crafts + this.bytes);
|
|
}
|
|
|
|
IAEItemStack getAmountCrafted(IAEItemStack what2) {
|
|
for (final IAEItemStack is : this.details.getOutputs()) {
|
|
if (is.equals(what2)) {
|
|
what2 = what2.copy();
|
|
what2.setStackSize(is.getStackSize());
|
|
return what2;
|
|
}
|
|
}
|
|
|
|
// more fuzzy!
|
|
for (final IAEItemStack is : this.details.getOutputs()) {
|
|
if (is.getItem() == what2.getItem()
|
|
&& (is.getItem().isDamageable() || is.getItemDamage() == what2.getItemDamage())) {
|
|
what2 = is.copy();
|
|
what2.setStackSize(is.getStackSize());
|
|
return what2;
|
|
}
|
|
}
|
|
|
|
throw new IllegalStateException("Crafting Tree construction failed.");
|
|
}
|
|
|
|
void setSimulate() {
|
|
this.crafts = 0;
|
|
this.bytes = 0;
|
|
|
|
for (final CraftingTreeNode pro : this.nodes.keySet()) {
|
|
pro.setSimulate();
|
|
}
|
|
}
|
|
|
|
void setJob(final MECraftingInventory storage, final CraftingCPUCluster craftingCPUCluster, final IActionSource src)
|
|
throws CraftBranchFailure {
|
|
craftingCPUCluster.addCrafting(this.details, this.crafts);
|
|
|
|
for (final CraftingTreeNode pro : this.nodes.keySet()) {
|
|
pro.setJob(storage, craftingCPUCluster, src);
|
|
}
|
|
}
|
|
|
|
void getPlan(final IItemList<IAEItemStack> plan) {
|
|
for (IAEItemStack i : this.details.getOutputs()) {
|
|
i = i.copy();
|
|
i.setCountRequestable(i.getStackSize() * this.crafts);
|
|
plan.addRequestable(i);
|
|
}
|
|
|
|
for (final CraftingTreeNode pro : this.nodes.keySet()) {
|
|
pro.getPlan(plan);
|
|
}
|
|
}
|
|
}
|