generated from tilera/1710mod
347 lines
10 KiB
Java
347 lines
10 KiB
Java
package com.eloraam.redpower.core;
|
|
|
|
import com.eloraam.redpower.base.ItemHandsaw;
|
|
import net.minecraft.inventory.InventoryCrafting;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.crafting.IRecipe;
|
|
import net.minecraft.world.World;
|
|
|
|
public class CoverRecipe implements IRecipe {
|
|
private static ItemStack newCover(int num, int type, int mat) {
|
|
return new ItemStack(CoverLib.blockCoverPlate, num, type << 8 | mat);
|
|
}
|
|
|
|
private ItemStack getSawRecipe(InventoryCrafting inv, ItemStack saw, int sawpos, ItemStack mat, int matpos) {
|
|
int sp1 = sawpos & 15;
|
|
int sp2 = sawpos >> 4;
|
|
int mp1 = matpos & 15;
|
|
int mp2 = matpos >> 4;
|
|
int dmg = -1;
|
|
int mn1;
|
|
if (mat.getItem() == Item.getItemFromBlock(CoverLib.blockCoverPlate)) {
|
|
dmg = mat.getItemDamage();
|
|
mn1 = dmg & 0xFF;
|
|
dmg >>= 8;
|
|
} else {
|
|
Integer ihs = CoverLib.getMaterial(mat);
|
|
if (ihs == null) {
|
|
return null;
|
|
}
|
|
|
|
mn1 = ihs;
|
|
}
|
|
|
|
ItemHandsaw ihs1 = (ItemHandsaw)saw.getItem();
|
|
if (ihs1.getSharpness() < CoverLib.getHardness(mn1)) {
|
|
return null;
|
|
} else if (sp1 != mp1 || sp2 != mp2 + 1 && sp2 != mp2 - 1) {
|
|
if (sp2 == mp2 && (sp1 == mp1 + 1 || sp1 == mp1 - 1)) {
|
|
switch(dmg) {
|
|
case 0:
|
|
return newCover(2, 21, mn1);
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 18:
|
|
case 19:
|
|
case 20:
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
case 38:
|
|
default:
|
|
return null;
|
|
case 16:
|
|
return newCover(2, 22, mn1);
|
|
case 17:
|
|
return newCover(2, 23, mn1);
|
|
case 21:
|
|
return newCover(2, 18, mn1);
|
|
case 22:
|
|
return newCover(2, 19, mn1);
|
|
case 23:
|
|
return newCover(2, 20, mn1);
|
|
case 27:
|
|
return newCover(2, 39, mn1);
|
|
case 28:
|
|
return newCover(2, 40, mn1);
|
|
case 29:
|
|
return newCover(2, 41, mn1);
|
|
case 30:
|
|
return newCover(2, 42, mn1);
|
|
case 39:
|
|
return newCover(2, 35, mn1);
|
|
case 40:
|
|
return newCover(2, 36, mn1);
|
|
case 41:
|
|
return newCover(2, 37, mn1);
|
|
case 42:
|
|
return newCover(2, 38, mn1);
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
switch(dmg) {
|
|
case -1:
|
|
return newCover(2, 17, mn1);
|
|
case 16:
|
|
return newCover(2, 0, mn1);
|
|
case 17:
|
|
return newCover(2, 16, mn1);
|
|
case 25:
|
|
return newCover(2, 24, mn1);
|
|
case 26:
|
|
return newCover(2, 25, mn1);
|
|
case 29:
|
|
return newCover(2, 27, mn1);
|
|
case 33:
|
|
return newCover(2, 31, mn1);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private ItemStack getColumnRecipe(ItemStack mat) {
|
|
if (mat.getItem() != Item.getItemFromBlock(CoverLib.blockCoverPlate)) {
|
|
return null;
|
|
} else {
|
|
int dmg = mat.getItemDamage();
|
|
int mn = dmg & 0xFF;
|
|
dmg >>= 8;
|
|
switch(dmg) {
|
|
case 22:
|
|
return newCover(1, 43, mn);
|
|
case 23:
|
|
return newCover(1, 44, mn);
|
|
case 41:
|
|
return newCover(1, 45, mn);
|
|
case 43:
|
|
return newCover(1, 22, mn);
|
|
case 44:
|
|
return newCover(1, 23, mn);
|
|
case 45:
|
|
return newCover(1, 41, mn);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private ItemStack getMergeRecipe(int mn, int tth, int ic) {
|
|
int mc = mn >> 20;
|
|
mn &= 255;
|
|
switch(mc) {
|
|
case 0:
|
|
switch(tth) {
|
|
case 2:
|
|
return newCover(1, 16, mn);
|
|
case 3:
|
|
return newCover(1, 27, mn);
|
|
case 4:
|
|
return newCover(1, 17, mn);
|
|
case 5:
|
|
return newCover(1, 28, mn);
|
|
case 6:
|
|
return newCover(1, 29, mn);
|
|
case 7:
|
|
return newCover(1, 30, mn);
|
|
case 8:
|
|
return CoverLib.getItemStack(mn);
|
|
default:
|
|
return null;
|
|
}
|
|
case 1:
|
|
switch(tth) {
|
|
case 2:
|
|
return newCover(1, 25, mn);
|
|
case 3:
|
|
return newCover(1, 31, mn);
|
|
case 4:
|
|
return newCover(1, 26, mn);
|
|
case 5:
|
|
return newCover(1, 32, mn);
|
|
case 6:
|
|
return newCover(1, 33, mn);
|
|
case 7:
|
|
return newCover(1, 34, mn);
|
|
case 8:
|
|
return CoverLib.getItemStack(mn);
|
|
default:
|
|
return null;
|
|
}
|
|
case 16:
|
|
switch(tth) {
|
|
case 2:
|
|
return newCover(1, 0, mn);
|
|
case 4:
|
|
return newCover(1, 16, mn);
|
|
case 8:
|
|
return newCover(1, 17, mn);
|
|
case 16:
|
|
return CoverLib.getItemStack(mn);
|
|
default:
|
|
return null;
|
|
}
|
|
case 32:
|
|
if (ic == 2) {
|
|
switch(tth) {
|
|
case 2:
|
|
return newCover(1, 21, mn);
|
|
case 4:
|
|
return newCover(1, 22, mn);
|
|
case 8:
|
|
return newCover(1, 23, mn);
|
|
}
|
|
} else {
|
|
switch(tth) {
|
|
case 4:
|
|
return newCover(1, 0, mn);
|
|
case 8:
|
|
return newCover(1, 16, mn);
|
|
case 16:
|
|
return newCover(1, 17, mn);
|
|
case 32:
|
|
return CoverLib.getItemStack(mn);
|
|
}
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private ItemStack getHollowRecipe(int mn) {
|
|
int mc = mn >> 8 & 0xFF;
|
|
mn &= 255;
|
|
switch(mc) {
|
|
case 0:
|
|
return newCover(8, 24, mn);
|
|
case 16:
|
|
return newCover(8, 25, mn);
|
|
case 17:
|
|
return newCover(8, 26, mn);
|
|
case 27:
|
|
return newCover(8, 31, mn);
|
|
case 28:
|
|
return newCover(8, 32, mn);
|
|
case 29:
|
|
return newCover(8, 33, mn);
|
|
case 30:
|
|
return newCover(8, 34, mn);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private int getMicroClass(ItemStack ist) {
|
|
if (ist.getItem() != Item.getItemFromBlock(CoverLib.blockCoverPlate)) {
|
|
return -1;
|
|
} else {
|
|
int dmg = ist.getItemDamage();
|
|
return CoverLib.damageToCoverData(dmg);
|
|
}
|
|
}
|
|
|
|
private ItemStack findResult(InventoryCrafting inv) {
|
|
ItemStack saw = null;
|
|
ItemStack mat = null;
|
|
boolean bad = false;
|
|
boolean allmicro = true;
|
|
boolean strict = true;
|
|
int sp = 0;
|
|
int mp = 0;
|
|
int mn = -1;
|
|
int tth = 0;
|
|
int ic = 0;
|
|
|
|
for(int i = 0; i < 3; ++i) {
|
|
for(int j = 0; j < 3; ++j) {
|
|
ItemStack ist = inv.getStackInRowAndColumn(i, j);
|
|
if (ist != null) {
|
|
if (ist.getItem() instanceof ItemHandsaw) {
|
|
if (saw != null) {
|
|
bad = true;
|
|
} else {
|
|
saw = ist;
|
|
sp = i + j * 16;
|
|
}
|
|
} else if (mat == null) {
|
|
mat = ist;
|
|
mp = i + j * 16;
|
|
mn = this.getMicroClass(ist);
|
|
if (mn >= 0) {
|
|
tth += mn >> 16 & 15;
|
|
} else {
|
|
allmicro = false;
|
|
}
|
|
|
|
ic = 1;
|
|
} else {
|
|
bad = true;
|
|
if (allmicro) {
|
|
int t = this.getMicroClass(ist);
|
|
if (((t ^ mn) & -1048321) != 0) {
|
|
allmicro = false;
|
|
} else {
|
|
if (t != mn) {
|
|
strict = false;
|
|
}
|
|
|
|
tth += t >> 16 & 15;
|
|
++ic;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (saw != null && mat != null && !bad) {
|
|
return this.getSawRecipe(inv, saw, sp, mat, mp);
|
|
} else if (saw == null && mat != null && !bad) {
|
|
return this.getColumnRecipe(mat);
|
|
} else if (!allmicro || !bad || saw != null) {
|
|
return null;
|
|
} else {
|
|
return ic == 8 && strict && inv.getStackInRowAndColumn(1, 1) == null && mn >> 20 == 0 ? this.getHollowRecipe(mn) : this.getMergeRecipe(mn, tth, ic);
|
|
}
|
|
}
|
|
|
|
public boolean matches(InventoryCrafting inv, World world) {
|
|
return this.findResult(inv) != null;
|
|
}
|
|
|
|
public int getRecipeSize() {
|
|
return 9;
|
|
}
|
|
|
|
public ItemStack getCraftingResult(InventoryCrafting inv) {
|
|
return this.findResult(inv).copy();
|
|
}
|
|
|
|
public ItemStack getRecipeOutput() {
|
|
return new ItemStack(CoverLib.blockCoverPlate, 1, 0);
|
|
}
|
|
}
|