1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
package kubatech.api.implementations;
import static kubatech.api.Variables.ln2;
import static kubatech.api.Variables.ln4;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Function;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import com.gtnewhorizons.modularui.api.drawable.IDrawable;
import com.gtnewhorizons.modularui.api.widget.Widget;
import gregtech.api.gui.modularui.GT_UITextures;
import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase;
public abstract class KubaTechGTMultiBlockBase<T extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<T>>
extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<T> {
protected KubaTechGTMultiBlockBase(int aID, String aName, String aNameRegional) {
super(aID, aName, aNameRegional);
}
protected KubaTechGTMultiBlockBase(String aName) {
super(aName);
}
/**
* Enables infinite overclocking (will give more outputs with more energy past 1 tick) Currently doesn't support
* recipe inputs
*
* @return If this supports infinite overclock
*/
protected boolean isOverclockingInfinite() {
return false;
}
/**
* @return The minimum amount of ticks this multiblock can overclock to
*/
protected int getOverclockTimeLimit() {
return 1;
}
@Override
protected void calculateOverclockedNessMultiInternal(long aEUt, int aDuration, int mAmperage, long maxInputVoltage,
boolean perfectOC) {
calculateOverclock(aEUt, aDuration, getMaxInputEu(), perfectOC);
}
/**
* @param aEUt Recipe EU/t
* @param aDuration Recipe duration (in ticks)
* @param maxInputEU The amount of energy we want to overclock to
* @param isPerfect Is this overclock perfect ?
* @return The amount of overclocks
*/
protected int calculateOverclock(long aEUt, int aDuration, final long maxInputEU, final boolean isPerfect) {
final int minDuration = getOverclockTimeLimit();
int tiers = (int) (Math.log((double) maxInputEU / (double) aEUt) / ln4);
if (tiers <= 0) {
this.lEUt = aEUt;
this.mMaxProgresstime = aDuration;
return 0;
}
int durationTiers = (int) Math
.ceil(Math.log((double) aDuration / (double) minDuration) / (isPerfect ? ln4 : ln2));
if (durationTiers < 0) durationTiers = 0; // We do not support downclocks (yet)
if (durationTiers > tiers) durationTiers = tiers;
if (!isOverclockingInfinite()) {
tiers = durationTiers;
if (tiers == 0) {
this.lEUt = aEUt;
this.mMaxProgresstime = aDuration;
return 0;
}
this.lEUt = aEUt << (tiers << 1);
aDuration >>= isPerfect ? (tiers << 1) : tiers;
if (aDuration < minDuration) aDuration = minDuration;
this.mMaxProgresstime = aDuration;
return tiers;
}
this.lEUt = aEUt << (tiers << 1);
aDuration >>= isPerfect ? (durationTiers << 1) : durationTiers;
int dMulti = tiers - durationTiers;
if (dMulti > 0) {
dMulti = 1 << (isPerfect ? (dMulti << 1) : dMulti);
// TODO: Use more inputs???
final ArrayList<ItemStack> stacks = new ArrayList<>(Arrays.asList(this.mOutputItems));
for (ItemStack mOutputItem : this.mOutputItems) {
mOutputItem.stackSize *= dMulti;
int maxSize = mOutputItem.getMaxStackSize();
while (mOutputItem.stackSize > maxSize)
stacks.add(mOutputItem.splitStack(Math.min(mOutputItem.stackSize - maxSize, maxSize)));
}
if (stacks.size() != this.mOutputItems.length) this.mOutputItems = stacks.toArray(new ItemStack[0]);
for (FluidStack mOutputFluid : this.mOutputFluids) mOutputFluid.amount *= dMulti;
}
if (aDuration < minDuration) aDuration = minDuration;
this.mMaxProgresstime = aDuration;
return tiers;
}
protected int calculateOverclock(long aEUt, int aDuration, boolean isPerfect) {
return calculateOverclock(aEUt, aDuration, getMaxInputEu(), isPerfect);
}
protected int calculateOverclock(long aEUt, int aDuration) {
return calculateOverclock(aEUt, aDuration, false);
}
protected int calculatePerfectOverclock(long aEUt, int aDuration) {
return calculateOverclock(aEUt, aDuration, true);
}
@Override
public boolean isCorrectMachinePart(ItemStack aStack) {
return true;
}
@Override
public int getMaxEfficiency(ItemStack aStack) {
return 10000;
}
@Override
public int getDamageToComponent(ItemStack aStack) {
return 0;
}
@Override
public boolean explodesOnComponentBreak(ItemStack aStack) {
return false;
}
// ModularUI stuff
protected final Function<Widget, Boolean> isFixed = widget -> getIdealStatus() == getRepairStatus() && mMachine;
protected static final Function<Integer, IDrawable[]> toggleButtonBackgroundGetter = val -> {
if (val == 0) return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, GT_UITextures.OVERLAY_BUTTON_CROSS };
else return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, GT_UITextures.OVERLAY_BUTTON_CHECKMARK };
};
}
|
