diff options
Diffstat (limited to 'src/main/java/detrav')
26 files changed, 2753 insertions, 0 deletions
diff --git a/src/main/java/detrav/DetravLoaderAfterGTPreload.java b/src/main/java/detrav/DetravLoaderAfterGTPreload.java new file mode 100644 index 0000000000..45ce3c2381 --- /dev/null +++ b/src/main/java/detrav/DetravLoaderAfterGTPreload.java @@ -0,0 +1,21 @@ +package detrav; + +import detrav.items.DetravMetaGeneratedTool01; +import detrav.items.processing.ProcessingDetravToolProspector; + +/** + * Created by wital_000 on 18.03.2016. + */ +public class DetravLoaderAfterGTPreload implements Runnable { + + @Override + public void run() { + + // items + new DetravMetaGeneratedTool01(); + + // recipes and etc + new ProcessingDetravToolProspector(); + + } +} diff --git a/src/main/java/detrav/DetravScannerMod.java b/src/main/java/detrav/DetravScannerMod.java new file mode 100644 index 0000000000..d9efd632a0 --- /dev/null +++ b/src/main/java/detrav/DetravScannerMod.java @@ -0,0 +1,74 @@ +package detrav; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraftforge.common.config.Configuration; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.network.NetworkRegistry; +import detrav.net.DetravNetwork; +import detrav.proxies.CommonProxy; +import detrav.utils.DetravCreativeTab; +import detrav.utils.FluidColors; +import detrav.utils.GTppHelper; +import gregtech.GT_Version; +import gregtech.api.GregTechAPI; + +@Mod( + modid = DetravScannerMod.MODID, + version = GT_Version.VERSION, + dependencies = "required-after:IC2;required-after:gregtech;after:miscutils;after:bartworks") +public class DetravScannerMod { + + public static final String MODID = "detravscannermod"; + public static final boolean DEBUG_ENABLED = Boolean.parseBoolean(System.getProperty("com.detrav.debug", "false")); + public static final CreativeTabs TAB_DETRAV = new DetravCreativeTab(); + public static boolean isDreamcraftLoaded = false; + public static boolean isBartWorksLoaded = false; + public static boolean isGTppLoaded = false; + + @SidedProxy(clientSide = "detrav.proxies.ClientProxy", serverSide = "detrav.proxies.ServerProxy") + public static CommonProxy proxy; + + @Mod.Instance(DetravScannerMod.MODID) + public static DetravScannerMod instance; + + public DetravScannerMod() { + GregTechAPI.sAfterGTPreload.add(new DetravLoaderAfterGTPreload()); + isDreamcraftLoaded = Loader.isModLoaded("dreamcraft"); + isBartWorksLoaded = Loader.isModLoaded("bartworks"); + isGTppLoaded = Loader.isModLoaded("miscutils"); + + new DetravNetwork(); + } + + @EventHandler + public void preInit(FMLPreInitializationEvent event) { + Configuration Config = new Configuration(event.getSuggestedConfigurationFile()); + Config.load(); + + if (Config.hasChanged()) { + Config.save(); + } + + proxy.onPreInit(); + } + + @EventHandler + public void init(FMLInitializationEvent event) { + NetworkRegistry.INSTANCE.registerGuiHandler(instance, proxy); + proxy.onLoad(); + } + + @EventHandler + public void onPostLoad(FMLPostInitializationEvent aEvent) { + proxy.onPostLoad(); + if (isGTppLoaded) GTppHelper.generate_OreIDs(); + FluidColors.makeColors(); + } +} diff --git a/src/main/java/detrav/commands/DetravScannerCommand.java b/src/main/java/detrav/commands/DetravScannerCommand.java new file mode 100644 index 0000000000..76c6673be1 --- /dev/null +++ b/src/main/java/detrav/commands/DetravScannerCommand.java @@ -0,0 +1,158 @@ +package detrav.commands; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.chunk.Chunk; + +import gregtech.api.GregTechAPI; +import gregtech.api.enums.Materials; +import gregtech.api.util.GTLanguageManager; +import gregtech.common.blocks.TileEntityOres; + +/** + * Created by wital_000 on 17.03.2016. + */ +public class DetravScannerCommand implements ICommand { + + private List aliases; + + public DetravScannerCommand() { + this.aliases = new ArrayList<String>(); + this.aliases.add("DetravScanner"); + this.aliases.add("dscan"); + } + + @Override + public String getCommandName() { + return "DetravScanner"; + } + + @Override + public String getCommandUsage(ICommandSender sender) { + return "DetravScanner [\"Part of Greg ore name\"]"; + } + + @Override + public List getCommandAliases() { + return this.aliases; + } + + @Override + public void processCommand(ICommandSender sender, String[] args) { + int aX = 0; + int aZ = 0; + int aY = 0; + String name = null; + + ArrayList<String> strs = new ArrayList<>(); + for (int i = 0; i < args.length; i++) { + strs.add(args[i]); + if (args[i].startsWith("\"")) { + for (i++; i < args.length; i++) { + String temp = (String) strs.get(strs.size() - 1); + temp = temp + " " + args[i]; + temp = temp.replace("\"", ""); + strs.set(strs.size() - 1, temp); + if (args[i].endsWith("\"")) break; + } + } + } + args = new String[strs.size()]; + args = strs.toArray(args); + + switch (args.length) { + case 0: + break; + case 1: + if (args[0].toLowerCase() == "help") { + sendHelpMessage(sender); + return; + } + name = args[0]; + break; + default: + sendHelpMessage(sender); + return; + } + ChunkCoordinates c = sender.getPlayerCoordinates(); + if (name != null) name = name.toLowerCase(); + process(sender, (int) Math.floor(c.posX / 16.0), (int) Math.floor(c.posZ / 16.0), name); + } + + private void process(ICommandSender sender, int aX, int aZ, String fName) { + Chunk c = sender.getEntityWorld() + .getChunkFromChunkCoords(aX, aZ); + if (c == null) sender.addChatMessage(new ChatComponentText("ERROR")); + HashMap<String, Integer> ores = new HashMap<>(); + for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) { + int ySize = c.getHeightValue(x, z); + for (int y = 1; y < ySize; y++) { + Block b = c.getBlock(x, y, z); + if (b == GregTechAPI.sBlockOres1) { + TileEntity entity = c.getTileEntityUnsafe(x, y, z); + if (entity != null) { + TileEntityOres gt_entity = (TileEntityOres) entity; + short meta = gt_entity.getMetaData(); + String name = Materials.getLocalizedNameForItem( + GTLanguageManager.getTranslation(b.getUnlocalizedName() + "." + meta + ".name"), + meta % 1000); + if (name.startsWith("Small")) continue; + if (fName == null || name.toLowerCase() + .contains(fName)) { + if (!ores.containsKey(name)) ores.put(name, 1); + else { + int val = ores.get(name); + ores.put(name, val + 1); + } + } + } + } + } + + } + sender.addChatMessage(new ChatComponentText("*** Detrav Scanner Begin")); + for (String key : ores.keySet()) { + sender.addChatMessage(new ChatComponentText(String.format("%s : %d", key, ores.get(key)))); + } + sender.addChatMessage(new ChatComponentText("*** Detrav Scanner End")); + } + + private void sendHelpMessage(ICommandSender sender) { + sender.addChatMessage(new ChatComponentText(getCommandUsage(sender))); + } + + @Override + public boolean canCommandSenderUseCommand(ICommandSender p_71519_1_) { + return true; + } + + @Override + public List addTabCompletionOptions(ICommandSender sender, String[] args) { + if (args.length != 1) return null; + if ("help".startsWith(args[0].toLowerCase())) { + List result = new ArrayList(); + result.add("help"); + sendHelpMessage(sender); + return result; + } + return null; + } + + @Override + public boolean isUsernameIndex(String[] p_82358_1_, int p_82358_2_) { + return false; + } + + @Override + public int compareTo(Object o) { + return 0; + } +} diff --git a/src/main/java/detrav/enums/DetravToolDictNames.java b/src/main/java/detrav/enums/DetravToolDictNames.java new file mode 100644 index 0000000000..8f0c32df85 --- /dev/null +++ b/src/main/java/detrav/enums/DetravToolDictNames.java @@ -0,0 +1,9 @@ +package detrav.enums; + +/** + * Created by wital_000 on 19.03.2016. + */ +public enum DetravToolDictNames { + craftingToolElectricProspector, + craftingToolProspector, +} diff --git a/src/main/java/detrav/enums/Textures01.java b/src/main/java/detrav/enums/Textures01.java new file mode 100644 index 0000000000..4985707aa9 --- /dev/null +++ b/src/main/java/detrav/enums/Textures01.java @@ -0,0 +1,17 @@ +package detrav.enums; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class Textures01 { + + public static final IIconContainer[] mTextures = new IIconContainer[] { + new Textures.ItemIcons.CustomIcon("gt.detrav.metatool.01/PRO_PICK_HEAD"), + new Textures.ItemIcons.CustomIcon("gt.detrav.metatool.01/ELECTRIC_LuV_PRO_PICK_HEAD"), + new Textures.ItemIcons.CustomIcon("gt.detrav.metatool.01/ELECTRIC_ZPM_PRO_PICK_HEAD"), + new Textures.ItemIcons.CustomIcon("gt.detrav.metatool.01/ELECTRIC_UV_PRO_PICK_HEAD"), + new Textures.ItemIcons.CustomIcon("gt.detrav.metatool.01/ELECTRIC_UHV_PRO_PICK_HEAD"), }; +} diff --git a/src/main/java/detrav/events/DetravLoginEventHandler.java b/src/main/java/detrav/events/DetravLoginEventHandler.java new file mode 100644 index 0000000000..9a28c1ab93 --- /dev/null +++ b/src/main/java/detrav/events/DetravLoginEventHandler.java @@ -0,0 +1,24 @@ +package detrav.events; + +import net.minecraftforge.common.MinecraftForge; + +import cpw.mods.fml.common.FMLCommonHandler; + +/** + * Created by wital_000 on 18.04.2016. + */ +public class DetravLoginEventHandler { + + static boolean inited = false; + + public static void register() { + if (!inited) { + inited = true; + DetravLoginEventHandler handler = new DetravLoginEventHandler(); + MinecraftForge.EVENT_BUS.register(handler); + FMLCommonHandler.instance() + .bus() + .register(handler); + } + } +} diff --git a/src/main/java/detrav/gui/DetravScannerGUI.java b/src/main/java/detrav/gui/DetravScannerGUI.java new file mode 100644 index 0000000000..7e7b4964e3 --- /dev/null +++ b/src/main/java/detrav/gui/DetravScannerGUI.java @@ -0,0 +1,120 @@ +package detrav.gui; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; + +import org.lwjgl.opengl.GL11; + +import detrav.gui.textures.DetravMapTexture; +import gregtech.api.util.GTUtility; + +/** + * Created by wital_000 on 21.03.2016. + */ +public class DetravScannerGUI extends GuiScreen { + + public static final int GUI_ID = 20; + private static DetravMapTexture map = null; + OresList oresList = null; + + private final static int minHeight = 128; + private final static int minWidth = 128; + private int prevW; + private int prevH; + + private static final ResourceLocation back = new ResourceLocation("gregtech:textures/gui/propick.png"); + + public DetravScannerGUI() { + + } + + public static void newMap(DetravMapTexture aMap) { + if (map != null) { + map.deleteGlTexture(); + map = null; + } + map = aMap; + map.loadTexture(null); + } + + @Override + public void drawScreen(int x, int y, float f) { + this.drawDefaultBackground(); + if (map == null) return; + int currentWidth = Math.max(map.width, minWidth); + int currentHeight = Math.max(map.height, minHeight); + int aX = (this.width - currentWidth - 100) / 2; + int aY = (this.height - currentHeight) / 2; + + if (oresList == null || (prevW != width || prevH != height)) { + oresList = new OresList( + this, + 100, + currentHeight, + aY, + aY + currentHeight, + aX + currentWidth, + 10, + map.packet.ores, + ((name, invert) -> { if (map != null) map.loadTexture(null, name, invert); })); + prevW = width; + prevH = height; + } + + // draw back for ores + drawRect(aX, aY, aX + currentWidth + 100, aY + currentHeight, 0xFFC6C6C6); + map.glBindTexture(); + map.draw(aX, aY); + oresList.drawScreen(x, y, f); + mc.getTextureManager() + .bindTexture(back); + GL11.glColor4f(0xFF, 0xFF, 0xFF, 0xFF); + + // draw corners + drawTexturedModalRect(aX - 5, aY - 5, 0, 0, 5, 5);// leftTop + drawTexturedModalRect(aX + currentWidth + 100, aY - 5, 171, 0, 5, 5);// RightTop + drawTexturedModalRect(aX - 5, aY + currentHeight, 0, 161, 5, 5);// leftDown + drawTexturedModalRect(aX + currentWidth + 100, aY + currentHeight, 171, 161, 5, 5);// RightDown + + // draw edges + for (int i = aX; i < aX + currentWidth + 100; i += 128) + drawTexturedModalRect(i, aY - 5, 5, 0, Math.min(128, aX + currentWidth + 100 - i), 5); // top + for (int i = aX; i < aX + currentWidth + 100; i += 128) + drawTexturedModalRect(i, aY + currentHeight, 5, 161, Math.min(128, aX + currentWidth + 100 - i), 5); // down + for (int i = aY; i < aY + currentHeight; i += 128) + drawTexturedModalRect(aX - 5, i, 0, 5, 5, Math.min(128, aY + currentHeight - i)); // left + for (int i = aY; i < aY + currentHeight; i += 128) + drawTexturedModalRect(aX + currentWidth + 100, i, 171, 5, 5, Math.min(128, aY + currentHeight - i)); // right + + if (map.packet.ptype == 2) { + HashMap<Byte, Short>[][] fluidInfo = map.packet.map; + int tX = x - aX; + int tY = y - aY; + if (tX >= 0 && tY >= 0 && tX < fluidInfo.length && tY < fluidInfo[0].length) { + List<String> info = new ArrayList<>(); + if (fluidInfo[tX][tY] != null) { + short fluidId = fluidInfo[tX][tY].get((byte) 1); + short fluidAmount = fluidInfo[tX][tY].get((byte) 2); + if (fluidId != 0 && fluidAmount > 0) { + info.add( + StatCollector.translateToLocal("gui.detrav.scanner.tooltip.fluid_name") + + map.packet.metaMap.get(fluidId)); + info.add( + StatCollector.translateToLocal("gui.detrav.scanner.tooltip.fluid_amount") + + GTUtility.formatNumbers(fluidAmount) + + " L"); + } else info.add(StatCollector.translateToLocal("gui.detrav.scanner.tooltip.no_fluid")); + } else { + info.add(StatCollector.translateToLocal("gui.detrav.scanner.tooltip.no_fluid")); + } + func_146283_a(info, x, y); + } + } + } + +} diff --git a/src/main/java/detrav/gui/OresList.java b/src/main/java/detrav/gui/OresList.java new file mode 100644 index 0000000000..91252760ec --- /dev/null +++ b/src/main/java/detrav/gui/OresList.java @@ -0,0 +1,66 @@ +package detrav.gui; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.function.BiConsumer; + +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.Tessellator; + +import cpw.mods.fml.client.GuiScrollingList; + +class OresList extends GuiScrollingList { + + private final HashMap<String, Integer> ores; + private final List<String> keys; + private final GuiScreen parent; + private final BiConsumer<String, Boolean> onSelected; + private boolean invert = false; + + private int selected = -1; + + public OresList(GuiScreen parent, int width, int height, int top, int bottom, int left, int entryHeight, + HashMap<String, Integer> aOres, BiConsumer<String, Boolean> onSelected) { + super(parent.mc, width, height, top, bottom, left, entryHeight); + this.parent = parent; + this.onSelected = onSelected; + ores = aOres; + keys = new ArrayList<>(ores.keySet()); + Collections.sort(keys); + if (keys.size() > 1) keys.add(0, "All"); + selected = 0; + } + + @Override + protected int getSize() { + return keys.size(); + } + + @Override + protected void elementClicked(int index, boolean doubleClick) { + selected = index; + if (doubleClick) this.invert = !this.invert; + + if (onSelected != null) onSelected.accept(keys.get(index), this.invert); + } + + @Override + protected boolean isSelected(int index) { + return selected == index; + } + + @Override + protected void drawBackground() {} + + @Override + protected void drawSlot(int slotIdx, int entryRight, int slotTop, int slotBuffer, Tessellator tess) { + parent.drawString( + parent.mc.fontRenderer, + parent.mc.fontRenderer.trimStringToWidth(keys.get(slotIdx), listWidth - 10), + this.left + 3, + slotTop - 1, + ores.getOrDefault(keys.get(slotIdx), 0x7d7b76)); + } +} diff --git a/src/main/java/detrav/gui/textures/DetravMapTexture.java b/src/main/java/detrav/gui/textures/DetravMapTexture.java new file mode 100644 index 0000000000..e8e35dc82d --- /dev/null +++ b/src/main/java/detrav/gui/textures/DetravMapTexture.java @@ -0,0 +1,145 @@ +package detrav.gui.textures; + +import java.awt.Color; +import java.awt.image.BufferedImage; +import java.awt.image.WritableRaster; + +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.texture.AbstractTexture; +import net.minecraft.client.renderer.texture.TextureUtil; +import net.minecraft.client.resources.IResourceManager; + +import org.lwjgl.opengl.GL11; + +import detrav.net.ProspectingPacket; + +/** + * Created by wital_000 on 21.03.2016. + */ +public class DetravMapTexture extends AbstractTexture { + + public final ProspectingPacket packet; + private String selected = "All"; + public int width = -1; + public int height = -1; + public boolean invert = false; + + public DetravMapTexture(ProspectingPacket aPacket) { + packet = aPacket; + } + + private BufferedImage getImage() { + final int backgroundColor = invert ? Color.GRAY.getRGB() : Color.WHITE.getRGB(); + final int wh = (packet.size * 2 + 1) * 16; + + BufferedImage image = new BufferedImage(wh, wh, BufferedImage.TYPE_INT_ARGB); + WritableRaster raster = image.getRaster(); + + int playerI = packet.posX - (packet.chunkX - packet.size) * 16 - 1; // Correct player offset + int playerJ = packet.posZ - (packet.chunkZ - packet.size) * 16 - 1; + for (int i = 0; i < wh; i++) { + for (int j = 0; j < wh; j++) { + image.setRGB(i, j, backgroundColor); + if (packet.map[i][j] != null) { + if (packet.ptype == 0 || packet.ptype == 1) { + for (short meta : packet.map[i][j].values()) { + final String name = packet.metaMap.get(meta); + if (!selected.equals("All") && !selected.equals(name)) continue; + + image.setRGB(i, j, packet.ores.getOrDefault(name, Color.BLACK.getRGB()) | 0XFF000000); + break; + } + } else if (packet.ptype == 2) { + final short fluidId = packet.map[i][j].get((byte) 1), + fluidSize = packet.map[i][j].get((byte) 2); + final String name = packet.metaMap.get(fluidId); + + // Variables used to locate within a chunk. + final int k = (i % 16), l = (j % 16); + + if (((k + l * 16) * 3) < (fluidSize + 48) + && (selected.equals("All") || selected.equals(name))) { + image.setRGB(i, j, packet.ores.getOrDefault(name, Color.BLACK.getRGB()) | 0XFF000000); + } + } else if (packet.ptype == 3) { + final short meta = packet.map[i][j].get((byte) 1); + image.setRGB(i, j, ((meta & 0xFF) << 16) + ((meta & 0xFF) << 8) + ((meta & 0xFF)) | 0XFF000000); + } + } + // draw player pos + if (i == playerI || j == playerJ) { + raster.setSample(i, j, 0, (raster.getSample(i, j, 0) + 255) / 2); + raster.setSample(i, j, 1, raster.getSample(i, j, 1) / 2); + raster.setSample(i, j, 2, raster.getSample(i, j, 2) / 2); + } + // draw grid + if ((i) % 16 == 0 || (j) % 16 == 0) { + raster.setSample(i, j, 0, raster.getSample(i, j, 0) / 2); + raster.setSample(i, j, 1, raster.getSample(i, j, 1) / 2); + raster.setSample(i, j, 2, raster.getSample(i, j, 2) / 2); + } + + } + } + + return image; + } + + @Override + public void loadTexture(IResourceManager resourceManager) { + this.deleteGlTexture(); + if (packet != null) { + int tId = getGlTextureId(); + if (tId < 0) return; + TextureUtil.uploadTextureImageAllocate(this.getGlTextureId(), getImage(), false, false); + width = packet.getSize(); + height = packet.getSize(); + } + } + + public void loadTexture(IResourceManager resourceManager, boolean invert) { + this.invert = invert; + loadTexture(resourceManager); + } + + public void loadTexture(IResourceManager resourceManager, String selected, boolean invert) { + this.selected = selected; + loadTexture(resourceManager, invert); + } + + public int glBindTexture() { + if (this.glTextureId < 0) return this.glTextureId; + GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.getGlTextureId()); + return this.glTextureId; + } + + public void draw(int x, int y) { + float f = 1F / (float) width; + float f1 = 1F / (float) height; + int u = 0, v = 0; + Tessellator tessellator = Tessellator.instance; + tessellator.startDrawingQuads(); + tessellator.addVertexWithUV( + (double) (x), + (double) (y + height), + 0, + (double) ((float) (u) * f), + (double) ((float) (v + height) * f1)); + tessellator.addVertexWithUV( + (double) (x + width), + (double) (y + height), + 0, + (double) ((float) (u + width) * f), + (double) ((float) (v + height) * f1)); + tessellator.addVertexWithUV( + (double) (x + width), + (double) (y), + 0, + (double) ((float) (u + width) * f), + (double) ((float) (v) * f1)); + tessellator + .addVertexWithUV((double) (x), (double) (y), 0, (double) ((float) (u) * f), (double) ((float) (v) * f1)); + tessellator.draw(); + } + +} diff --git a/src/main/java/detrav/items/DetravMetaGeneratedTool01.java b/src/main/java/detrav/items/DetravMetaGeneratedTool01.java new file mode 100644 index 0000000000..e704631467 --- /dev/null +++ b/src/main/java/detrav/items/DetravMetaGeneratedTool01.java @@ -0,0 +1,359 @@ +package detrav.items; + +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +import detrav.DetravScannerMod; +import detrav.enums.DetravToolDictNames; +import detrav.items.tools.DetravProspector; +import detrav.items.tools.DetravToolElectricProspector; +import gregtech.api.enums.GTValues; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TCAspects; +import gregtech.api.interfaces.IToolStats; +import gregtech.api.items.MetaGeneratedTool; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class DetravMetaGeneratedTool01 extends MetaGeneratedTool { + + public static DetravMetaGeneratedTool01 INSTANCE; + + public DetravMetaGeneratedTool01() { + super("detrav.metatool.01"); + INSTANCE = this; + addTool( + 0, + "Prospector's Scanner(ULV)", + "", + new DetravProspector(0), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 2, + "Prospector's Scanner(LV)", + "", + new DetravProspector(1), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 4, + "Prospector's Scanner(MV)", + "", + new DetravProspector(2), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 6, + "Prospector's Scanner(HV)", + "", + new DetravProspector(3), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 8, + "Prospector's Scanner(EV)", + "", + new DetravProspector(4), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 10, + "Prospector's Scanner(IV)", + "", + new DetravProspector(5), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 12, + "Prospector's Scanner(LuV)", + "", + new DetravProspector(6), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 14, + "Prospector's Scanner(ZPM)", + "", + new DetravProspector(7), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 16, + "Prospector's Scanner(UV)", + "", + new DetravProspector(8), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + addTool( + 18, + "Prospector's Scanner(UHV)", + "", + new DetravProspector(9), + DetravToolDictNames.craftingToolProspector.toString(), + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.PERFODIO, 4L)); + + addTool( + 100, + "Electric Prospector's Scanner (LuV)", + "", + new DetravToolElectricProspector(6), + DetravToolDictNames.craftingToolElectricProspector, + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.ELECTRUM, 4L)); + addTool( + 102, + "Electric Prospector's Scanner (ZPM)", + "", + new DetravToolElectricProspector(7), + DetravToolDictNames.craftingToolElectricProspector, + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.ELECTRUM, 4L)); + addTool( + 104, + "Electric Prospector's Scanner (UV)", + "", + new DetravToolElectricProspector(8), + DetravToolDictNames.craftingToolElectricProspector, + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.ELECTRUM, 4L)); + addTool( + 106, + "Electric Prospector's Scanner (UHV)", + "", + new DetravToolElectricProspector(9), + DetravToolDictNames.craftingToolElectricProspector, + new TCAspects.TC_AspectStack(TCAspects.INSTRUMENTUM, 2L), + new TCAspects.TC_AspectStack(TCAspects.METALLUM, 4L), + new TCAspects.TC_AspectStack(TCAspects.ELECTRUM, 4L)); + setCreativeTab(DetravScannerMod.TAB_DETRAV); + } + + @SuppressWarnings("unchecked") + public void addAdditionalToolTips(List aList, ItemStack aStack, EntityPlayer aPlayer) { + long tMaxDamage = getToolMaxDamage(aStack); + Materials tMaterial = getPrimaryMaterial(aStack); + IToolStats tStats = getToolStats(aStack); + int tOffset = aList.size(); + if (tStats == null) return; + + String name = aStack.getUnlocalizedName(); + String num = name.substring("gt.detrav.metatool.01.".length()); + int meta = Integer.parseInt(num); + int range = getHarvestLevel(aStack, "") / 2 + (meta / 4); + if ((range % 2) == 0) { + range += 1; + } + if (meta < 100) { + aList.add( + tOffset + 0, + EnumChatFormatting.WHITE + StatCollector.translateToLocal("tooltip.detrav.scanner.durability") + + EnumChatFormatting.GREEN + + Long.toString(tMaxDamage - getToolDamage(aStack)) + + " / " + + Long.toString(tMaxDamage) + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 1, + EnumChatFormatting.WHITE + tMaterial.getLocalizedNameForItem("%material") + EnumChatFormatting.GRAY); + aList.add( + tOffset + 2, + EnumChatFormatting.WHITE + StatCollector.translateToLocal("tooltip.detrav.scanner.range") + + Integer.toString(range) + + "x" + + Integer.toString(range) + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 3, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.0") + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 4, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.1") + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 5, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.success.chance") + + EnumChatFormatting.RESET + + Integer.toString(((((1 + meta) * 8) <= 100) ? ((1 + meta) * 8) : 100)) + + EnumChatFormatting.GRAY + + "%"); + aList.add( + tOffset + 6, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.distance.0")); + aList.add( + tOffset + 7, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.distance.1")); + + } else if (meta >= 100 && meta < 200) { + aList.add( + tOffset + 0, + EnumChatFormatting.WHITE + StatCollector.translateToLocal("tooltip.detrav.scanner.durability") + + EnumChatFormatting.GREEN + + (tMaxDamage - getToolDamage(aStack)) + + " / " + + tMaxDamage + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 1, + EnumChatFormatting.WHITE + tMaterial.getLocalizedNameForItem("%material") + EnumChatFormatting.GRAY); + aList.add( + tOffset + 2, + EnumChatFormatting.WHITE + StatCollector.translateToLocal("tooltip.detrav.scanner.range") + + EnumChatFormatting.YELLOW + + (getHarvestLevel(aStack, "") * 2 + 1) + + "x" + + (getHarvestLevel(aStack, "") * 2 + 1) + + EnumChatFormatting.GRAY); + aList.add( + tOffset + 3, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.0")); + aList.add( + tOffset + 4, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.1")); + aList.add( + tOffset + 5, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.2")); + aList.add( + tOffset + 6, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.3")); + aList.add( + tOffset + 7, + EnumChatFormatting.ITALIC + StatCollector.translateToLocal("tooltip.detrav.scanner.usage.4")); + } + + } + + public Long getToolGTDetravData(ItemStack aStack) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) return aNBT.getLong("DetravData"); + } + return 0L; + } + + public boolean setToolGTDetravData(ItemStack aStack, long data) { + NBTTagCompound aNBT = aStack.getTagCompound(); + if (aNBT != null) { + aNBT = aNBT.getCompoundTag("GT.ToolStats"); + if (aNBT != null) { + aNBT.setLong("DetravData", data); + return true; + } + } + return false; + } + + @SuppressWarnings("unchecked") + public void getDetravSubItems(Item item, CreativeTabs detravCreativeTab, List list) { + + ItemStack dStack; + if (DetravScannerMod.isDreamcraftLoaded) { + // Materials at tiers + list.add(getToolWithStats(0, 1, Materials.Polycaprolactam, Materials.Polycaprolactam, null)); + list.add(getToolWithStats(2, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(2, 1, Materials.Bronze, Materials.Steel, null)); + list.add(getToolWithStats(4, 1, Materials.Manyullyn, Materials.Aluminium, null)); + list.add(getToolWithStats(6, 1, Materials.DamascusSteel, Materials.DamascusSteel, null)); + list.add(getToolWithStats(8, 1, Materials.Titanium, Materials.Titanium, null)); + list.add(getToolWithStats(10, 1, Materials.TungstenSteel, Materials.TungstenSteel, null)); + list.add(getToolWithStats(12, 1, Materials.Iridium, Materials.Iridium, null)); + list.add(getToolWithStats(12, 1, Materials.Osmium, Materials.Osmium, null)); + list.add(getToolWithStats(14, 1, Materials.Neutronium, Materials.Neutronium, null)); + list.add(getToolWithStats(16, 1, Materials.InfinityCatalyst, Materials.InfinityCatalyst, null)); + list.add(getToolWithStats(18, 1, Materials.Infinity, Materials.Infinity, null)); + } + + // Steel for comparison + list.add(getToolWithStats(0, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(2, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(4, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(6, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(8, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(10, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(12, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(14, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(16, 1, Materials.Steel, Materials.Steel, null)); + list.add(getToolWithStats(18, 1, Materials.Steel, Materials.Steel, null)); + + // Electric Scanners + dStack = getToolWithStats( + 100, + 1, + Materials.Iridium, + Materials.TungstenSteel, + new long[] { 102400000L, GTValues.V[6], 6L, -1L }); + setCharge(dStack, 102400000L); + list.add(dStack); + + dStack = getToolWithStats( + 102, + 1, + Materials.Neutronium, + Materials.TungstenSteel, + new long[] { 409600000L, GTValues.V[7], 7L, -1L }); + setCharge(dStack, 409600000L); + list.add(dStack); + + if (DetravScannerMod.isDreamcraftLoaded) { + dStack = getToolWithStats( + 104, + 1, + Materials.InfinityCatalyst, + Materials.TungstenSteel, + new long[] { 1638400000L, GTValues.V[8], 8L, -1L }); + setCharge(dStack, 1638400000L); + list.add(dStack); + + dStack = getToolWithStats( + 106, + 1, + Materials.Infinity, + Materials.TungstenSteel, + new long[] { 6553600000L, GTValues.V[9], 9L, -1L }); + setCharge(dStack, 6553600000L); + list.add(dStack); + } else { + dStack = getToolWithStats( + 106, + 1, + Materials.Neutronium, + Materials.TungstenSteel, + new long[] { 6553600000L, GTValues.V[9], 9L, -1L }); + setCharge(dStack, 6553600000L); + list.add(dStack); + } + } +} diff --git a/src/main/java/detrav/items/behaviours/BehaviourDetravToolElectricProspector.java b/src/main/java/detrav/items/behaviours/BehaviourDetravToolElectricProspector.java new file mode 100644 index 0000000000..25da8b6277 --- /dev/null +++ b/src/main/java/detrav/items/behaviours/BehaviourDetravToolElectricProspector.java @@ -0,0 +1,253 @@ +package detrav.items.behaviours; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import net.minecraftforge.fluids.FluidStack; + +import com.sinthoras.visualprospecting.VisualProspecting_API; + +import cpw.mods.fml.common.Loader; +import detrav.DetravScannerMod; +import detrav.items.DetravMetaGeneratedTool01; +import detrav.net.DetravNetwork; +import detrav.net.ProspectingPacket; +import detrav.utils.BartWorksHelper; +import detrav.utils.GTppHelper; +import gregtech.api.items.MetaBaseItem; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.common.UndergroundOil; +import gregtech.common.blocks.BlockOresAbstract; +import gregtech.common.blocks.TileEntityOres; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class BehaviourDetravToolElectricProspector extends BehaviourDetravToolProspector { + + public BehaviourDetravToolElectricProspector(int aCosts) { + super(aCosts); + } + + public ItemStack onItemRightClick(MetaBaseItem aItem, ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + if (!aWorld.isRemote) { + int data = DetravMetaGeneratedTool01.INSTANCE.getToolGTDetravData(aStack) + .intValue(); + if (aPlayer.isSneaking()) { + data++; + if (data > 3) data = 0; + switch (data) { + case 0: + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.mode.0"))); + break; + case 1: + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.mode.1"))); + break; + case 2: + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.mode.2"))); + break; + case 3: + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.mode.3"))); + break; + default: + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.mode.error"))); + break; + } + DetravMetaGeneratedTool01.INSTANCE.setToolGTDetravData(aStack, (long) data); + return super.onItemRightClick(aItem, aStack, aWorld, aPlayer); + } + + final DetravMetaGeneratedTool01 tool = (DetravMetaGeneratedTool01) aItem; + final int cX = ((int) aPlayer.posX) >> 4; + final int cZ = ((int) aPlayer.posZ) >> 4; + int size = aItem.getHarvestLevel(aStack, "") + 1; + final List<Chunk> chunks = new ArrayList<>(); + aPlayer.addChatMessage(new ChatComponentText("Scanning...")); + + for (int i = -size; i <= size; i++) + for (int j = -size; j <= size; j++) if (i != -size && i != size && j != -size && j != size) + chunks.add(aWorld.getChunkFromChunkCoords(cX + i, cZ + j)); + size = size - 1; + + final ProspectingPacket packet = new ProspectingPacket( + cX, + cZ, + (int) aPlayer.posX, + (int) aPlayer.posZ, + size, + data); + final String small_ore_keyword = StatCollector.translateToLocal("detrav.scanner.small_ore.keyword"); + for (Chunk c : chunks) { + for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) { + final int ySize = c.getHeightValue(x, z); + for (int y = 1; y < ySize; y++) { + switch (data) { + case 0: + case 1: + final Block tBlock = c.getBlock(x, y, z); + short tMetaID = (short) c.getBlockMetadata(x, y, z); + if (tBlock instanceof BlockOresAbstract) { + TileEntity tTileEntity = c.getTileEntityUnsafe(x, y, z); + if ((tTileEntity instanceof TileEntityOres) + && ((TileEntityOres) tTileEntity).mNatural) { + tMetaID = (short) ((TileEntityOres) tTileEntity).getMetaData(); + try { + String name = GTLanguageManager + .getTranslation(tBlock.getUnlocalizedName() + "." + tMetaID + ".name"); + if (data != 1 && name.startsWith(small_ore_keyword)) continue; + packet.addBlock(c.xPosition * 16 + x, y, c.zPosition * 16 + z, tMetaID); + } catch (Exception e) { + String name = tBlock.getUnlocalizedName() + "."; + if (data != 1 && name.contains(".small.")) continue; + packet.addBlock(c.xPosition * 16 + x, y, c.zPosition * 16 + z, tMetaID); + } + } + } else if (DetravScannerMod.isGTppLoaded && GTppHelper.isGTppBlock(tBlock)) { + packet.addBlock( + c.xPosition * 16 + x, + y, + c.zPosition * 16 + z, + GTppHelper.getGTppMeta(tBlock)); + } else if (DetravScannerMod.isBartWorksLoaded && BartWorksHelper.isOre(tBlock)) { + if (data != 1 && BartWorksHelper.isSmallOre(tBlock)) continue; + packet.addBlock( + c.xPosition * 16 + x, + y, + c.zPosition * 16 + z, + BartWorksHelper.getMetaFromBlock(c, x, y, z, tBlock)); + } else if (data == 1) { + ItemData tAssotiation = GTOreDictUnificator + .getAssociation(new ItemStack(tBlock, 1, tMetaID)); + if ((tAssotiation != null) && (tAssotiation.mPrefix.toString() + .startsWith("ore"))) { + packet.addBlock( + c.xPosition * 16 + x, + y, + c.zPosition * 16 + z, + (short) tAssotiation.mMaterial.mMaterial.mMetaItemSubID); + } + } + break; + case 2: + if ((x == 0) || (z == 0)) { // Skip doing the locations with the grid on them. + break; + } + FluidStack fStack = UndergroundOil.undergroundOil( + aWorld.getChunkFromBlockCoords(c.xPosition * 16 + x, c.zPosition * 16 + z), + -1); + if (fStack.amount > 0) { + packet.addBlock( + c.xPosition * 16 + x, + 1, + c.zPosition * 16 + z, + (short) fStack.getFluidID()); + packet + .addBlock(c.xPosition * 16 + x, 2, c.zPosition * 16 + z, (short) fStack.amount); + } + break; + case 3: + float polution = (float) getPolution( + aWorld, + c.xPosition * 16 + x, + c.zPosition * 16 + z); + polution /= 2000000; + polution *= -0xFF; + if (polution > 0xFF) polution = 0xFF; + polution = 0xFF - polution; + packet.addBlock(c.xPosition * 16 + x, 1, c.zPosition * 16 + z, (short) polution); + break; + } + if (data > 1) break; + } + } + } + packet.level = ((DetravMetaGeneratedTool01) aItem).getHarvestLevel(aStack, ""); + DetravNetwork.INSTANCE.sendToPlayer(packet, (EntityPlayerMP) aPlayer); + if (!aPlayer.capabilities.isCreativeMode) tool.doDamage(aStack, this.mCosts * chunks.size()); + + if (Loader.isModLoaded("visualprospecting")) { + if (data == 0 || data == 1) { + VisualProspecting_API.LogicalServer.sendProspectionResultsToClient( + (EntityPlayerMP) aPlayer, + VisualProspecting_API.LogicalServer.prospectOreVeinsWithinRadius( + aWorld.provider.dimensionId, + (int) aPlayer.posX, + (int) aPlayer.posZ, + size * 16), + new ArrayList<>()); + } else if (data == 2) { + VisualProspecting_API.LogicalServer.sendProspectionResultsToClient( + (EntityPlayerMP) aPlayer, + new ArrayList<>(), + VisualProspecting_API.LogicalServer.prospectUndergroundFluidsWithingRadius( + aWorld, + (int) aPlayer.posX, + (int) aPlayer.posZ, + size * 16)); + } + } + } + return super.onItemRightClick(aItem, aStack, aWorld, aPlayer); + } + + void addChatMassageByValue(EntityPlayer aPlayer, int value, String name) { + if (value < 0) { + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.6") + name)); + } else if (value < 1) { + aPlayer + .addChatMessage(new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.6"))); + } else aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.6") + name + " " + value)); + } + + public boolean onItemUse(MetaBaseItem aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, + int aZ, int aSide, float hitX, float hitY, float hitZ) { + long data = DetravMetaGeneratedTool01.INSTANCE.getToolGTDetravData(aStack); + if (data < 2) { + if (aWorld.getBlock(aX, aY, aZ) == Blocks.bedrock) { + if (!aWorld.isRemote) { + FluidStack fStack = UndergroundOil.undergroundOil(aWorld.getChunkFromBlockCoords(aX, aZ), -1); + addChatMassageByValue(aPlayer, fStack.amount, fStack.getLocalizedName()); + if (!aPlayer.capabilities.isCreativeMode) + ((DetravMetaGeneratedTool01) aItem).doDamage(aStack, this.mCosts); + } + return true; + } else { + if (!aWorld.isRemote) { + prospectSingleChunk((DetravMetaGeneratedTool01) aItem, aStack, aPlayer, aWorld, aX, aY, aZ); + } + return true; + } + } + if (data < 3) if (!aWorld.isRemote) { + FluidStack fStack = UndergroundOil.undergroundOil(aWorld.getChunkFromBlockCoords(aX, aZ), -1); + addChatMassageByValue(aPlayer, fStack.amount, fStack.getLocalizedName()); + if (!aPlayer.capabilities.isCreativeMode) ((DetravMetaGeneratedTool01) aItem).doDamage(aStack, this.mCosts); + return true; + } + if (!aWorld.isRemote) { + int polution = getPolution(aWorld, aX, aZ); + addChatMassageByValue(aPlayer, polution, "Pollution"); + } + return true; + } + +} diff --git a/src/main/java/detrav/items/behaviours/BehaviourDetravToolProspector.java b/src/main/java/detrav/items/behaviours/BehaviourDetravToolProspector.java new file mode 100644 index 0000000000..c914640573 --- /dev/null +++ b/src/main/java/detrav/items/behaviours/BehaviourDetravToolProspector.java @@ -0,0 +1,420 @@ +package detrav.items.behaviours; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.SplittableRandom; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import net.minecraftforge.fluids.FluidStack; + +import com.sinthoras.visualprospecting.VisualProspecting_API; + +import bartworks.system.material.Werkstoff; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.LanguageRegistry; +import detrav.DetravScannerMod; +import detrav.items.DetravMetaGeneratedTool01; +import detrav.utils.BartWorksHelper; +import detrav.utils.GTppHelper; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.Materials; +import gregtech.api.items.MetaBaseItem; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.common.Pollution; +import gregtech.common.UndergroundOil; +import gregtech.common.blocks.BlockOresAbstract; +import gregtech.common.blocks.TileEntityOres; +import gregtech.common.items.behaviors.BehaviourNone; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class BehaviourDetravToolProspector extends BehaviourNone { + + static final int[] DISTANCEINTS = new int[] { 0, 4, 25, 64 }; + int distTextIndex; + + HashMap<String, Integer> ores; + int badluck; + + protected final int mCosts; + + static final String CHAT_MSG_SEPARATOR = "--------------------"; + + public BehaviourDetravToolProspector(int aCosts) { + mCosts = aCosts; + } + + public boolean onItemUse(MetaBaseItem aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, + int aZ, int aSide, float hitX, float hitY, float hitZ) { + + SplittableRandom aRandom = new SplittableRandom(); + int chance = ((1 + aStack.getItemDamage()) * 8) > 100 ? 100 : (1 + aStack.getItemDamage()) * 8; + + if (aWorld.isRemote) return false; + + if (aWorld.getBlock(aX, aY, aZ) == Blocks.bedrock) { + if (!aWorld.isRemote && aRandom.nextInt(100) < chance) { + FluidStack fStack = UndergroundOil.undergroundOil(aWorld.getChunkFromBlockCoords(aX, aZ), -1); + addChatMassageByValue(aPlayer, fStack.amount / 2, "a Fluid");// fStack.getLocalizedName()); + /* + * boolean fluid = GT_UndergroundOil.undergroundOil(aWorld.getChunkFromBlockCoords(aX, aZ), -1)!=null + * &>_UndergroundOil.undergroundOil(aWorld.getChunkFromBlockCoords(aX, aZ), -1).getFluid()!=null; if + * (fluid) aPlayer.addChatMessage(new + * ChatComponentText(EnumChatFormatting.GREEN+"You found some liquid.")); else + * aPlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED+"You found no liquid.")); + */ + if (!aPlayer.capabilities.isCreativeMode) + ((DetravMetaGeneratedTool01) aItem).doDamage(aStack, this.mCosts); + + if (Loader.isModLoaded("visualprospecting")) { + VisualProspecting_API.LogicalServer.sendProspectionResultsToClient( + (EntityPlayerMP) aPlayer, + new ArrayList<>(), + VisualProspecting_API.LogicalServer + .prospectUndergroundFluidsWithingRadius(aWorld, (int) aPlayer.posX, (int) aPlayer.posZ, 0)); + } + } + return true; + } + if (aWorld.getBlock(aX, aY, aZ) + .getMaterial() == Material.rock + || aWorld.getBlock(aX, aY, aZ) + .getMaterial() == Material.ground + || aWorld.getBlock(aX, aY, aZ) == GregTechAPI.sBlockOres1) { + if (!aWorld.isRemote) { + prospectChunks((DetravMetaGeneratedTool01) aItem, aStack, aPlayer, aWorld, aX, aY, aZ, aRandom, chance); + } + return true; + } + return false; + } + + protected void prospectChunks(MetaBaseItem aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, SplittableRandom aRandom, int chance) { + int bX = aX; + int bZ = aZ; + + badluck = 0; + ores = new HashMap<>(); + + int range = ((DetravMetaGeneratedTool01) aItem).getHarvestLevel(aStack, "") / 2 + (aStack.getItemDamage() / 4); + if ((range % 2) == 0) { + range += 1; // kinda not needed here, divide takes it out, but we put it back in with the range+1 in the + // loop + } + range = range / 2; // Convert range from diameter to radius + + aPlayer.addChatMessage( + new ChatComponentText( + EnumChatFormatting.GOLD + GTLanguageManager.sEnglishFile + .get("LanguageFile", "gt.scanner.prospecting", "Prospecting at ") + .getString() + EnumChatFormatting.BLUE + "(" + bX + ", " + bZ + ")")); + for (int x = -(range); x < (range + 1); ++x) { + aX = bX + (x * 16); + for (int z = -(range); z < (range + 1); ++z) { + + aZ = bZ + (z * 16); + int dist = x * x + z * z; + + for (distTextIndex = 0; distTextIndex < DISTANCEINTS.length; distTextIndex++) { + if (dist <= DISTANCEINTS[distTextIndex]) { + break; + } + } + if (DetravScannerMod.DEBUG_ENABLED) aPlayer.addChatMessage( + new ChatComponentText( + EnumChatFormatting.YELLOW + "Chunk at " + + aX + + "|" + + aZ + + " to " + + (aX + 16) + + "|" + + (aZ + 16) + + StatCollector.translateToLocal("detrav.scanner.distance.texts." + distTextIndex))); + processOreProspecting( + (DetravMetaGeneratedTool01) aItem, + aStack, + aPlayer, + aWorld.getChunkFromBlockCoords(aX, aZ), + aWorld.getTileEntity(aX, aY, aZ), + GTOreDictUnificator.getAssociation( + new ItemStack(aWorld.getBlock(aX, aY, aZ), 1, aWorld.getBlockMetadata(aX, aY, aZ))), + aRandom, + chance); + } + } + + // List to hold unsorted scanner messages + List<ChatComponentText> oreMessages = new ArrayList<ChatComponentText>(); + + for (String key : ores.keySet()) { + int value = ores.get(key); + appendChatMessageByValue(oreMessages, aPlayer, value, key); + } + + // Define sort order by distance + List<String> sortOrder = Arrays.asList( + StatCollector.translateToLocal("detrav.scanner.distance.texts.4"), + StatCollector.translateToLocal("detrav.scanner.distance.texts.3"), + StatCollector.translateToLocal("detrav.scanner.distance.texts.2"), + StatCollector.translateToLocal("detrav.scanner.distance.texts.1"), + StatCollector.translateToLocal("detrav.scanner.distance.texts.0")); + + List<ChatComponentText> oreMessagesSorted = new ArrayList<ChatComponentText>(); + oreMessagesSorted.add(new ChatComponentText(CHAT_MSG_SEPARATOR)); + + // Sort ore messages by distance, separated by ----- + for (String oreFrequency : sortOrder) { + for (ChatComponentText msg : oreMessages) { + if (msg.getChatComponentText_TextValue() + .contains(oreFrequency)) { + oreMessagesSorted.add(msg); + } + } + + // Only append ----- separator if text has been added + if (!oreMessagesSorted.get(oreMessagesSorted.size() - 1) + .getChatComponentText_TextValue() + .contains(CHAT_MSG_SEPARATOR)) { + oreMessagesSorted.add(new ChatComponentText(CHAT_MSG_SEPARATOR)); + } + } + + if (badluck == 0) { + oreMessages.add( + new ChatComponentText( + EnumChatFormatting.WHITE + StatCollector.translateToLocal("detrav.scanner.success"))); + } else { + oreMessages.add( + new ChatComponentText( + EnumChatFormatting.WHITE + StatCollector.translateToLocal("detrav.scanner.fail") + .replace("%badluck", Integer.toString(badluck)))); + } + + // Print the sorted messages + for (ChatComponentText msg : oreMessagesSorted) { + aPlayer.addChatMessage(msg); + } + + if (Loader.isModLoaded("visualprospecting")) { + VisualProspecting_API.LogicalServer.sendProspectionResultsToClient( + (EntityPlayerMP) aPlayer, + VisualProspecting_API.LogicalServer.prospectOreVeinsWithinRadius( + aWorld.provider.dimensionId, + (int) aPlayer.posX, + (int) aPlayer.posZ, + range * 16), + new ArrayList<>()); + } + } + + // Used by Electric scanner when scanning the chunk whacked by the scanner. 100% chance find rate + protected void prospectSingleChunk(MetaBaseItem aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ) { + ores = new HashMap<>(); + aPlayer.addChatMessage( + new ChatComponentText( + EnumChatFormatting.GOLD + StatCollector.translateToLocal( + "detrav.scanner.prospecting") + EnumChatFormatting.BLUE + "(" + aX + ", " + aZ + ")")); + processOreProspecting( + (DetravMetaGeneratedTool01) aItem, + aStack, + aPlayer, + aWorld.getChunkFromBlockCoords(aX, aZ), + aWorld.getTileEntity(aX, aY, aZ), + GTOreDictUnificator + .getAssociation(new ItemStack(aWorld.getBlock(aX, aY, aZ), 1, aWorld.getBlockMetadata(aX, aY, aZ))), + new SplittableRandom(), + 1000); + + for (String key : ores.keySet()) { + int value = ores.get(key); + addChatMassageByValue(aPlayer, value, key); + } + + if (Loader.isModLoaded("visualprospecting")) { + VisualProspecting_API.LogicalServer.sendProspectionResultsToClient( + (EntityPlayerMP) aPlayer, + VisualProspecting_API.LogicalServer.prospectOreVeinsWithinRadius( + aWorld.provider.dimensionId, + (int) aPlayer.posX, + (int) aPlayer.posZ, + 0), + new ArrayList<>()); + } + } + + protected void processOreProspecting(DetravMetaGeneratedTool01 aItem, ItemStack aStack, EntityPlayer aPlayer, + Chunk aChunk, TileEntity aTileEntity, ItemData tAssotiation, SplittableRandom aRandom, int chance)// TileEntity + // aTileEntity) + { + if (aTileEntity != null) { + if (aTileEntity instanceof TileEntityOres) { + TileEntityOres gt_entity = (TileEntityOres) aTileEntity; + short meta = gt_entity.getMetaData(); + String format = LanguageRegistry.instance() + .getStringLocalization("gt.blockores." + meta + ".name"); + String name = Materials.getLocalizedNameForItem(format, meta % 1000); + addOreToHashMap(name, aPlayer); + if (!aPlayer.capabilities.isCreativeMode) aItem.doDamage(aStack, this.mCosts); + return; + } + } else if (tAssotiation != null) { + try { + String name = tAssotiation.toString(); + addChatMassageByValue(aPlayer, -1, name); + if (!aPlayer.capabilities.isCreativeMode) aItem.doDamage(aStack, this.mCosts); + return; + } catch (Exception e) { + addChatMassageByValue(aPlayer, -1, "ERROR, lol ^_^"); + } + } else if (aRandom.nextInt(100) < chance) { + final int data = DetravMetaGeneratedTool01.INSTANCE.getToolGTDetravData(aStack) + .intValue(); + final String small_ore_keyword = StatCollector.translateToLocal("detrav.scanner.small_ore.keyword"); + for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) { + int ySize = aChunk.getHeightValue(x, z); + for (int y = 1; y < ySize; y++) { + + Block tBlock = aChunk.getBlock(x, y, z); + short tMetaID = (short) aChunk.getBlockMetadata(x, y, z); + if (tBlock instanceof BlockOresAbstract) { + TileEntity tTileEntity = aChunk.getTileEntityUnsafe(x, y, z); + if ((tTileEntity instanceof TileEntityOres) && ((TileEntityOres) tTileEntity).mNatural) { + tMetaID = (short) ((TileEntityOres) tTileEntity).getMetaData(); + try { + String format = LanguageRegistry.instance() + .getStringLocalization(tBlock.getUnlocalizedName() + "." + tMetaID + ".name"); + String name = Materials.getLocalizedNameForItem(format, tMetaID % 1000); + if (data != 1 && name.startsWith(small_ore_keyword)) continue; + addOreToHashMap(name, aPlayer); + } catch (Exception e) { + String name = tBlock.getUnlocalizedName() + "."; + if (data != 1 && name.contains(".small.")) continue; + addOreToHashMap(name, aPlayer); + } + } + } else if (DetravScannerMod.isGTppLoaded && GTppHelper.isGTppBlock(tBlock)) { + String name = GTppHelper.getGTppVeinName(tBlock); + if (!name.isEmpty()) addOreToHashMap(name, aPlayer); + } else if (DetravScannerMod.isBartWorksLoaded && BartWorksHelper.isOre(tBlock)) { + if (data != 1 && BartWorksHelper.isSmallOre(tBlock)) continue; + final Werkstoff werkstoff = Werkstoff.werkstoffHashMap.getOrDefault( + (short) ((BartWorksHelper.getMetaFromBlock(aChunk, x, y, z, tBlock)) * -1), + null); + String type = BartWorksHelper.isSmallOre(tBlock) ? "oreSmall" : "ore"; + String translated = GTLanguageManager.getTranslation("bw.blocktype." + type); + addOreToHashMap(translated.replace("%material", werkstoff.getLocalizedName()), aPlayer); + } else if (data == 1) { + tAssotiation = GTOreDictUnificator.getAssociation(new ItemStack(tBlock, 1, tMetaID)); + if ((tAssotiation != null) && (tAssotiation.mPrefix.toString() + .startsWith("ore"))) { + try { + try { + tMetaID = (short) tAssotiation.mMaterial.mMaterial.mMetaItemSubID; + String format = LanguageRegistry.instance() + .getStringLocalization("gt.blockores." + tMetaID + ".name"); + String name = Materials.getLocalizedNameForItem(format, tMetaID % 1000); + addOreToHashMap(name, aPlayer); + } catch (Exception e1) { + String name = tAssotiation.toString(); + addOreToHashMap(name, aPlayer); + } + } catch (Exception ignored) {} + } + } + + } + } + + if (!aPlayer.capabilities.isCreativeMode) aItem.doDamage(aStack, this.mCosts); + + return; + } else { + if (DetravScannerMod.DEBUG_ENABLED) + aPlayer.addChatMessage(new ChatComponentText(EnumChatFormatting.RED + " Failed on this chunk")); + badluck++; + if (!aPlayer.capabilities.isCreativeMode) aItem.doDamage(aStack, this.mCosts / 4); + } + // addChatMassageByValue(aPlayer,0,null); + } + + void addOreToHashMap(String orename, EntityPlayer aPlayer) { + String oreDistance = orename + StatCollector.translateToLocal("detrav.scanner.distance.texts." + distTextIndex); // orename + // + + // the + // textual + // distance + // of + // the + // ore + if (!ores.containsKey(oreDistance)) { + if (DetravScannerMod.DEBUG_ENABLED) aPlayer + .addChatMessage(new ChatComponentText(EnumChatFormatting.GREEN + " Adding to oremap " + oreDistance)); + ores.put(oreDistance, 1); + } else { + int val = ores.get(oreDistance); + ores.put(oreDistance, val + 1); + } + } + + void addChatMassageByValue(EntityPlayer aPlayer, int value, String name) { + if (value < 0) { + aPlayer.addChatMessage( + new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.6") + name)); + } else if (value < 1) { + aPlayer + .addChatMessage(new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.0"))); + } else if (value < 10) aPlayer.addChatMessage( + new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.1"))); + else if (value < 30) aPlayer.addChatMessage( + new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.2"))); + else if (value < 60) aPlayer.addChatMessage( + new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.3"))); + else if (value < 100) aPlayer.addChatMessage( + new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.4"))); + else aPlayer.addChatMessage( + new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.5"))); + } + + // Same as addChatMassageByValue but appends to a list of chat messages and spelled correctly + void appendChatMessageByValue(List<ChatComponentText> chatMessageList, EntityPlayer aPlayer, int value, + String name) { + if (value < 0) { + chatMessageList + .add(new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.6") + name)); + } else if (value < 1) { + chatMessageList.add(new ChatComponentText(StatCollector.translateToLocal("detrav.scanner.found.texts.0"))); + } else if (value < 10) chatMessageList + .add(new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.1"))); + else if (value < 30) chatMessageList + .add(new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.2"))); + else if (value < 60) chatMessageList + .add(new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.3"))); + else if (value < 100) chatMessageList + .add(new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.4"))); + else chatMessageList + .add(new ChatComponentText(name + StatCollector.translateToLocal("detrav.scanner.found.texts.5"))); + } + + public static int getPolution(World aWorld, int aX, int aZ) { + return Pollution.getPollution(aWorld.getChunkFromBlockCoords(aX, aZ)); + } +} diff --git a/src/main/java/detrav/items/processing/ProcessingDetravToolProspector.java b/src/main/java/detrav/items/processing/ProcessingDetravToolProspector.java new file mode 100644 index 0000000000..4ae83edc72 --- /dev/null +++ b/src/main/java/detrav/items/processing/ProcessingDetravToolProspector.java @@ -0,0 +1,129 @@ +package detrav.items.processing; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import detrav.DetravScannerMod; +import detrav.items.DetravMetaGeneratedTool01; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GTModHandler; + +/** + * Created by wital_000 on 18.03.2016. + */ +public class ProcessingDetravToolProspector implements gregtech.api.interfaces.IOreRecipeRegistrator { + + public ProcessingDetravToolProspector() { + OrePrefixes.toolHeadPickaxe.add(this); + } + + public void registerOre(OrePrefixes aPrefix, Materials material, String aOreDictName, String aModName, + ItemStack aStack) { + if (!aPrefix.doGenerateItem(material)) return; + if (DetravScannerMod.DEBUG_ENABLED) return; + try { + // ULV disabled + // GTModHandler.addCraftingRecipe(DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(0, 1, aMaterial, + // Materials.Lead, null), GTModHandler.RecipeBits.DISMANTLEABLE | + // GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GTModHandler.RecipeBits.BUFFERED, new + // Object[]{"SHE","CPC","PXP",'E',OreDictionary.getOres("cellSulfuricAcid").get(0),'S',OreDictionary.getOres("cellHydroxide").get(0),'H',OrePrefixes.toolHeadDrill.get(aMaterial),'P',OrePrefixes.plate.get(aMaterial),'C',OrePrefixes.circuit.get(Materials.Primitive),'X',gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList.Sensor_ULV}); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(2, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellSulfuricAcid") + .get(0), 'S', + OreDictionary.getOres("cellHydroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Basic), 'X', ItemList.Sensor_LV }); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(4, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellSulfuricAcid") + .get(0), 'S', + OreDictionary.getOres("cellHydroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Good), 'X', ItemList.Sensor_MV }); + + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(6, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellNitricAcid") + .get(0), 'S', + OreDictionary.getOres("cellSodiumPersulfate") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Advanced), 'X', ItemList.Sensor_HV }); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(8, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellNitricAcid") + .get(0), 'S', + OreDictionary.getOres("cellSodiumPersulfate") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Data), 'X', ItemList.Sensor_EV }); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(10, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellNitricAcid") + .get(0), 'S', + OreDictionary.getOres("cellSodiumPersulfate") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Elite), 'X', ItemList.Sensor_IV }); + + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(12, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellHydrofluoricAcid") + .get(0), 'S', + OreDictionary.getOres("cellLithiumPeroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Master), 'X', ItemList.Sensor_LuV }); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(14, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellHydrofluoricAcid") + .get(0), 'S', + OreDictionary.getOres("cellLithiumPeroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Ultimate), 'X', ItemList.Sensor_ZPM }); + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(16, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellHydrofluoricAcid") + .get(0), 'S', + OreDictionary.getOres("cellLithiumPeroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.SuperconductorUHV), 'X', ItemList.Sensor_UV }); + + GTModHandler.addCraftingRecipe( + DetravMetaGeneratedTool01.INSTANCE.getToolWithStats(18, 1, material, Materials.Steel, null), + GTModHandler.RecipeBits.DISMANTLEABLE | GTModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS + | GTModHandler.RecipeBits.BUFFERED, + new Object[] { "SHE", "CPC", "PXP", 'E', OreDictionary.getOres("cellHydrofluoricAcid") + .get(0), 'S', + OreDictionary.getOres("cellHydrogenPeroxide") + .get(0), + 'H', OrePrefixes.toolHeadDrill.get(material), 'P', OrePrefixes.plate.get(material), 'C', + OrePrefixes.circuit.get(Materials.Infinite), 'X', ItemList.Sensor_UHV }); + + } catch (Exception ignored) {} + + } +} diff --git a/src/main/java/detrav/items/tools/DetravProspector.java b/src/main/java/detrav/items/tools/DetravProspector.java new file mode 100644 index 0000000000..63eb0e1452 --- /dev/null +++ b/src/main/java/detrav/items/tools/DetravProspector.java @@ -0,0 +1,34 @@ +package detrav.items.tools; + +import net.minecraft.item.ItemStack; + +import detrav.enums.Textures01; +import detrav.items.behaviours.BehaviourDetravToolProspector; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.items.MetaGeneratedTool; + +public class DetravProspector extends DetravToolElectricProspectorBase { + + private final int tier; + + public DetravProspector(int tier) { + this.tier = tier; + } + + public int getBaseQuality() { + return tier; + } + + public float getMaxDurabilityMultiplier() { + double x = tier + 1; + return (float) (((float) 0.005D + Math.tanh(Math.pow(x, (x / 8D)) / 25D) * (x / 6D)) * 1.25); + } + + public IIconContainer getIcon(boolean aIsToolHead, ItemStack aStack) { + return Textures01.mTextures[0]; + } + + public void onStatsAddedToTool(MetaGeneratedTool aItem, int aID) { + aItem.addItemBehavior(aID, new BehaviourDetravToolProspector(15)); + } +} diff --git a/src/main/java/detrav/items/tools/DetravToolElectricProspector.java b/src/main/java/detrav/items/tools/DetravToolElectricProspector.java new file mode 100644 index 0000000000..abe5259036 --- /dev/null +++ b/src/main/java/detrav/items/tools/DetravToolElectricProspector.java @@ -0,0 +1,33 @@ +package detrav.items.tools; + +import net.minecraft.item.ItemStack; + +import detrav.enums.Textures01; +import gregtech.api.interfaces.IIconContainer; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class DetravToolElectricProspector extends DetravToolElectricProspectorBase { + + private final int tier; + + public DetravToolElectricProspector(int tier) { + this.tier = tier; + } + + public int getBaseQuality() { + return tier - 6; + } + + public float getMaxDurabilityMultiplier() { + if (tier - 6 == 0) return (float) Math.pow(((float) ((tier - 6F) * 2F)), 0.0D); + else return (float) ((tier - 6F) * 2F); + } + + public IIconContainer getIcon(boolean aIsToolHead, ItemStack aStack) { + + if (tier <= 9 && tier >= 6) return Textures01.mTextures[tier - 5]; + else return Textures01.mTextures[1]; + } +} diff --git a/src/main/java/detrav/items/tools/DetravToolElectricProspectorBase.java b/src/main/java/detrav/items/tools/DetravToolElectricProspectorBase.java new file mode 100644 index 0000000000..f73344fc6b --- /dev/null +++ b/src/main/java/detrav/items/tools/DetravToolElectricProspectorBase.java @@ -0,0 +1,200 @@ +package detrav.items.tools; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.stats.AchievementList; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.DamageSource; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IChatComponent; +import net.minecraft.world.World; +import net.minecraftforge.event.world.BlockEvent; + +import detrav.enums.Textures01; +import detrav.items.behaviours.BehaviourDetravToolElectricProspector; +import gregtech.api.GregTechAPI; +import gregtech.api.damagesources.GTDamageSources; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.IToolStats; +import gregtech.api.items.MetaGeneratedTool; + +/** + * Created by wital_000 on 19.03.2016. modified by bartimaeusnek on 05.06.2018 + */ +public class DetravToolElectricProspectorBase implements IToolStats { + + public int getToolDamagePerBlockBreak() { + return 100; + } + + public int getToolDamagePerDropConversion() { + return 100; + } + + public int getToolDamagePerContainerCraft() { + return 100; + } + + public int getToolDamagePerEntityAttack() { + return 2000; + } + + public int getBaseQuality() { + return 0; + } + + public float getBaseDamage() { + return 1.0F; + } + + @Override + public int getHurtResistanceTime(int i, Entity entity) { + return i; + } + + public float getSpeedMultiplier() { + return 1.0F; + } + + public float getMaxDurabilityMultiplier() { + return 1.0F; + } + + @Override + public DamageSource getDamageSource(EntityLivingBase aPlayer, Entity aEntity) { + return GTDamageSources.getCombatDamage( + (aPlayer instanceof EntityPlayer) ? "player" : "mob", + aPlayer, + (aEntity instanceof EntityLivingBase) ? getDeathMessage(aPlayer, (EntityLivingBase) aEntity) : null); + } + + public String getCraftingSound() { + return null; + } + + public String getEntityHitSound() { + return null; + } + + public String getBreakingSound() { + return (String) GregTechAPI.sSoundList.get(0); + } + + @Override + public Enchantment[] getEnchantments(ItemStack itemStack) { + return new Enchantment[0]; + } + + @Override + public int[] getEnchantmentLevels(ItemStack itemStack) { + return new int[0]; + } + + public String getMiningSound() { + return null; + } + + public boolean canBlock() { + return false; + } + + public boolean isCrowbar() { + return false; + } + + @Override + public boolean isGrafter() { + return false; + } + + @Override + public boolean isChainsaw() { + return false; + } + + @Override + public boolean isWrench() { + return false; + } + + @Override + public boolean isWeapon() { + return false; + } + + @Override + public boolean isRangedWeapon() { + return false; + } + + @Override + public boolean isMiningTool() { + return false; + } + + public boolean isMinableBlock(Block aBlock, byte aMetaData) { + + return false; + } + + @Override + public int convertBlockDrops(List<ItemStack> list, ItemStack itemStack, EntityPlayer entityPlayer, Block block, + int i, int i1, int i2, byte b, int i3, boolean b1, BlockEvent.HarvestDropsEvent harvestDropsEvent) { + return 0; + } + + public ItemStack getBrokenItem(ItemStack aStack) { + return null; + } + + @Override + public float getNormalDamageAgainstEntity(float v, Entity entity, ItemStack itemStack, EntityPlayer entityPlayer) { + return v; + } + + @Override + public float getMagicDamageAgainstEntity(float v, Entity entity, ItemStack itemStack, EntityPlayer entityPlayer) { + return v; + } + + public IIconContainer getIcon(boolean aIsToolHead, ItemStack aStack) { + return Textures01.mTextures[0]; + } + + public short[] getRGBa(boolean aIsToolHead, ItemStack aStack) { + return aIsToolHead ? MetaGeneratedTool.getPrimaryMaterial(aStack).mRGBa + : MetaGeneratedTool.getSecondaryMaterial(aStack).mRGBa; + } + + public void onStatsAddedToTool(MetaGeneratedTool aItem, int aID) { + aItem.addItemBehavior(aID, new BehaviourDetravToolElectricProspector(getToolDamagePerBlockBreak())); + } + + public void onToolCrafted(ItemStack aStack, EntityPlayer aPlayer) { + + aPlayer.triggerAchievement(AchievementList.openInventory); + aPlayer.triggerAchievement(AchievementList.mineWood); + aPlayer.triggerAchievement(AchievementList.buildWorkBench); + } + + public IChatComponent getDeathMessage(EntityLivingBase aPlayer, EntityLivingBase aEntity) { + return new ChatComponentText( + EnumChatFormatting.RED + aEntity.getCommandSenderName() + + EnumChatFormatting.WHITE + + " got Pick Up'ed by " + + EnumChatFormatting.GREEN + + aPlayer.getCommandSenderName() + + EnumChatFormatting.WHITE); + } + + public float getMiningSpeed(Block aBlock, byte aMetaData, float aDefault, EntityPlayer aPlayer, World aWorld, + int aX, int aY, int aZ) { + return aDefault; + } +} diff --git a/src/main/java/detrav/net/DetravNetwork.java b/src/main/java/detrav/net/DetravNetwork.java new file mode 100644 index 0000000000..30bdb23157 --- /dev/null +++ b/src/main/java/detrav/net/DetravNetwork.java @@ -0,0 +1,83 @@ +package detrav.net; + +import java.util.EnumMap; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayerMP; + +import cpw.mods.fml.common.network.FMLEmbeddedChannel; +import cpw.mods.fml.common.network.FMLOutboundHandler; +import cpw.mods.fml.common.network.NetworkRegistry; +import cpw.mods.fml.common.network.internal.FMLProxyPacket; +import cpw.mods.fml.relauncher.Side; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufInputStream; +import io.netty.buffer.ByteBufOutputStream; +import io.netty.buffer.Unpooled; +import io.netty.channel.ChannelHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.SimpleChannelInboundHandler; +import io.netty.handler.codec.MessageToMessageCodec; + +/** + * Created by wital_000 on 20.03.2016. + */ +@ChannelHandler.Sharable +public class DetravNetwork extends MessageToMessageCodec<FMLProxyPacket, DetravPacket> { + + static public DetravNetwork INSTANCE; + private final EnumMap<Side, FMLEmbeddedChannel> mChannel; + + public DetravNetwork() { + INSTANCE = this; + this.mChannel = NetworkRegistry.INSTANCE.newChannel("DetravScanner", this, new HandlerShared()); + } + + @Override + protected void encode(ChannelHandlerContext ctx, DetravPacket msg, List<Object> out) throws Exception { + ByteBuf buf = Unpooled.buffer(); + buf.writeByte(msg.getPacketID()); + msg.encode(new ByteBufOutputStream(buf)); + out.add( + new FMLProxyPacket( + buf, + ctx.channel() + .attr(NetworkRegistry.FML_CHANNEL) + .get())); + } + + @Override + protected void decode(ChannelHandlerContext ctx, FMLProxyPacket msg, List<Object> out) throws Exception { + ByteBuf payload = msg.payload(); + payload.readByte(); // Sub Channel - Ignore + out.add(ProspectingPacket.decode(new ByteBufInputStream(payload))); + } + + public void sendToPlayer(DetravPacket aPacket, EntityPlayerMP aPlayer) { + this.mChannel.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.PLAYER); + this.mChannel.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGETARGS) + .set(aPlayer); + this.mChannel.get(Side.SERVER) + .writeAndFlush(aPacket); + } + + public void sendToServer(DetravPacket aPacket) { + this.mChannel.get(Side.CLIENT) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.TOSERVER); + this.mChannel.get(Side.CLIENT) + .writeAndFlush(aPacket); + } + + @ChannelHandler.Sharable + static final class HandlerShared extends SimpleChannelInboundHandler<DetravPacket> { + + @Override + protected void channelRead0(ChannelHandlerContext ctx, DetravPacket aPacket) { + aPacket.process(); + } + } +} diff --git a/src/main/java/detrav/net/DetravPacket.java b/src/main/java/detrav/net/DetravPacket.java new file mode 100644 index 0000000000..ca71fefd5e --- /dev/null +++ b/src/main/java/detrav/net/DetravPacket.java @@ -0,0 +1,16 @@ +package detrav.net; + +import java.io.IOException; +import java.io.OutputStream; + +/** + * Created by wital_000 on 20.03.2016. + */ +public abstract class DetravPacket { + + public abstract int getPacketID(); + + public abstract void encode(OutputStream out) throws IOException; + + public abstract void process(); +} diff --git a/src/main/java/detrav/net/ProspectingPacket.java b/src/main/java/detrav/net/ProspectingPacket.java new file mode 100644 index 0000000000..bfa22511e3 --- /dev/null +++ b/src/main/java/detrav/net/ProspectingPacket.java @@ -0,0 +1,191 @@ +package detrav.net; + +import java.io.DataInput; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.HashMap; +import java.util.zip.GZIPInputStream; +import java.util.zip.GZIPOutputStream; + +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.google.common.base.Objects; + +import bartworks.system.material.Werkstoff; +import detrav.DetravScannerMod; +import detrav.gui.DetravScannerGUI; +import detrav.gui.textures.DetravMapTexture; +import detrav.utils.GTppHelper; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.Materials; +import gregtech.api.util.GTLanguageManager; + +/** + * Created by wital_000 on 20.03.2016. + */ +public class ProspectingPacket extends DetravPacket { + + public final int chunkX; + public final int chunkZ; + public final int posX; + public final int posZ; + public final int size; + public final int ptype; + public final HashMap<Byte, Short>[][] map; + public final HashMap<String, Integer> ores; + public final HashMap<Short, String> metaMap; + public static final HashMap<Integer, short[]> fluidColors = new HashMap<>(); + + public int level = -1; + + public ProspectingPacket(int chunkX, int chunkZ, int posX, int posZ, int size, int ptype) { + this.chunkX = chunkX; + this.chunkZ = chunkZ; + this.posX = posX; + this.posZ = posZ; + this.size = size; + this.ptype = ptype; + this.map = new HashMap[(size * 2 + 1) * 16][(size * 2 + 1) * 16]; + this.ores = new HashMap<>(); + this.metaMap = new HashMap<>(); + } + + private static void addOre(ProspectingPacket packet, byte y, int i, int j, short meta) { + final String name; + short[] rgba; + + try { + if (packet.ptype == 0 || packet.ptype == 1) { + // Ore or Small Ore + if (meta < 7000 || meta > 7500) { + if (meta > 0) { + Materials tMaterial = GregTechAPI.sGeneratedMaterials[meta % 1000]; + rgba = tMaterial.getRGBA(); + name = tMaterial.getLocalizedNameForItem( + GTLanguageManager.getTranslation("gt.blockores." + meta + ".name")); + } else { + final Werkstoff werkstoff = Werkstoff.werkstoffHashMap.getOrDefault((short) (meta * -1), null); + String translated = GTLanguageManager.getTranslation("bw.blocktype.ore"); + name = translated.replace("%material", werkstoff.getLocalizedName()); + rgba = werkstoff != null ? werkstoff.getRGBA() : new short[] { 0, 0, 0, 0 }; + } + } else { + gtPlusPlus.core.material.Material pMaterial = GTppHelper.decodeoresGTpp.get((short) (meta - 7000)); + rgba = pMaterial.getRGBA(); + name = pMaterial.getLocalizedName() + " Ore"; + } + } else if (packet.ptype == 2) { + // Fluid + rgba = fluidColors.get((int) meta); + if (rgba == null) { + DetravScannerMod.proxy + .sendPlayerExeption("Unknown fluid ID = " + meta + " Please add to FluidColors.java!"); + rgba = new short[] { 0, 0, 0, 0 }; + } + + name = Objects.firstNonNull( + FluidRegistry.getFluid(meta) + .getLocalizedName(new FluidStack(FluidRegistry.getFluid(meta), 0)), + StatCollector.translateToLocal("gui.detrav.scanner.unknown_fluid")); + } else if (packet.ptype == 3) { + // Pollution + name = StatCollector.translateToLocal("gui.detrav.scanner.pollution"); + rgba = new short[] { 125, 123, 118, 0 }; + } else { + return; + } + } catch (Exception ignored) { + return; + } + packet.ores.put(name, ((rgba[0] & 0xFF) << 16) + ((rgba[1] & 0xFF) << 8) + ((rgba[2] & 0xFF))); + packet.metaMap.put(meta, name); + } + + public static Object decode(InputStream in) throws IOException { + DataInput aData = new DataInputStream(new GZIPInputStream(in)); + ProspectingPacket packet = new ProspectingPacket( + aData.readInt(), + aData.readInt(), + aData.readInt(), + aData.readInt(), + aData.readInt(), + aData.readInt()); + packet.level = aData.readInt(); + + int aSize = (packet.size * 2 + 1) * 16; + int checkOut = 0; + for (int i = 0; i < aSize; i++) for (int j = 0; j < aSize; j++) { + byte kSize = aData.readByte(); + if (kSize == 0) continue; + packet.map[i][j] = new HashMap<>(); + for (int k = 0; k < kSize; k++) { + final byte y = aData.readByte(); + final short meta = aData.readShort(); + packet.map[i][j].put(y, meta); + if (packet.ptype != 2 || y == 1) addOre(packet, y, i, j, meta); + checkOut++; + } + } + int checkOut2 = aData.readInt(); + if (checkOut != checkOut2) return null; + return packet; + } + + @Override + public int getPacketID() { + return 0; + } + + @Override + public void encode(OutputStream out) throws IOException { + DataOutputStream tOut = new DataOutputStream(new GZIPOutputStream(out)); + tOut.writeInt(chunkX); + tOut.writeInt(chunkZ); + tOut.writeInt(posX); + tOut.writeInt(posZ); + tOut.writeInt(size); + tOut.writeInt(ptype); + tOut.writeInt(level); + + int aSize = (size * 2 + 1) * 16; + int checkOut = 0; + for (int i = 0; i < aSize; i++) for (int j = 0; j < aSize; j++) { + HashMap<Byte, Short> data = map[i][j]; + if (data == null) tOut.writeByte(0); + else { + tOut.writeByte( + data.keySet() + .size()); + for (byte key : data.keySet()) { + tOut.writeByte(key); + tOut.writeShort(data.get(key)); + checkOut++; + } + } + } + tOut.writeInt(checkOut); + tOut.close(); + } + + @Override + public void process() { + DetravScannerGUI.newMap(new DetravMapTexture(this)); + DetravScannerMod.proxy.openProspectorGUI(); + } + + public void addBlock(int x, int y, int z, short metaData) { + int aX = x - (chunkX - size) * 16; + int aZ = z - (chunkZ - size) * 16; + if (map[aX][aZ] == null) map[aX][aZ] = new HashMap<>(); + map[aX][aZ].put((byte) y, metaData); + } + + public int getSize() { + return (size * 2 + 1) * 16; + } +} diff --git a/src/main/java/detrav/proxies/ClientProxy.java b/src/main/java/detrav/proxies/ClientProxy.java new file mode 100644 index 0000000000..fa0aac05b0 --- /dev/null +++ b/src/main/java/detrav/proxies/ClientProxy.java @@ -0,0 +1,49 @@ +package detrav.proxies; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.EntityPlayer; + +import detrav.DetravScannerMod; +import detrav.enums.Textures01; +import detrav.gui.DetravScannerGUI; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class ClientProxy extends CommonProxy { + + public ClientProxy() { + int test = Textures01.mTextures.length; + } + + @Override + public void onPostLoad() { + super.onPostLoad(); + } + + @Override + public void onLoad() { + super.onLoad(); + } + + public void openProspectorGUI() { + EntityPlayer player = Minecraft.getMinecraft().thePlayer; + player.openGui( + DetravScannerMod.instance, + DetravScannerGUI.GUI_ID, + player.worldObj, + (int) player.posX, + (int) player.posY, + (int) player.posZ); + } + + @Override + public void onPreInit() { + super.onPreInit(); + } + + @Override + public void sendPlayerExeption(String s) { + Minecraft.getMinecraft().thePlayer.sendChatMessage("DetravScannerMod: " + s); + } +} diff --git a/src/main/java/detrav/proxies/CommonProxy.java b/src/main/java/detrav/proxies/CommonProxy.java new file mode 100644 index 0000000000..f8e0500eea --- /dev/null +++ b/src/main/java/detrav/proxies/CommonProxy.java @@ -0,0 +1,54 @@ +package detrav.proxies; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; + +import cpw.mods.fml.common.network.IGuiHandler; +import detrav.events.DetravLoginEventHandler; +import detrav.gui.DetravScannerGUI; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class CommonProxy implements IGuiHandler { + + public void onLoad() { + + } + + public void onPostLoad() { + DetravLoginEventHandler.register(); + } + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + switch (ID) { + case DetravScannerGUI.GUI_ID: + return null; + default: + return null; + } + } + + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + switch (ID) { + case DetravScannerGUI.GUI_ID: + return new DetravScannerGUI(); + default: + return null; + } + } + + public void openProspectorGUI() { + // just Client code + } + + public void onPreInit() { + + } + + public void sendPlayerExeption(String s) { + + } +} diff --git a/src/main/java/detrav/proxies/ServerProxy.java b/src/main/java/detrav/proxies/ServerProxy.java new file mode 100644 index 0000000000..d0875a7163 --- /dev/null +++ b/src/main/java/detrav/proxies/ServerProxy.java @@ -0,0 +1,22 @@ +package detrav.proxies; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class ServerProxy extends CommonProxy { + + @Override + public void onPostLoad() { + super.onPostLoad(); + } + + @Override + public void onLoad() { + super.onLoad(); + } + + @Override + public void onPreInit() { + super.onPreInit(); + } +} diff --git a/src/main/java/detrav/utils/BartWorksHelper.java b/src/main/java/detrav/utils/BartWorksHelper.java new file mode 100644 index 0000000000..1bbadc71c7 --- /dev/null +++ b/src/main/java/detrav/utils/BartWorksHelper.java @@ -0,0 +1,23 @@ +package detrav.utils; + +import net.minecraft.block.Block; +import net.minecraft.world.chunk.Chunk; + +import bartworks.system.material.BWMetaGeneratedOres; +import bartworks.system.material.BWMetaGeneratedSmallOres; + +public class BartWorksHelper { + + public static boolean isOre(Block tBlock) { + return tBlock instanceof BWMetaGeneratedOres; + } + + public static boolean isSmallOre(Block tBlock) { + return tBlock instanceof BWMetaGeneratedSmallOres; + } + + public static short getMetaFromBlock(Chunk c, int x, int y, int z, Block tBlock) { + return (short) (tBlock.getDamageValue(c.worldObj, c.xPosition * 16 + x, y, c.zPosition * 16 + z) * -1); + } + +} diff --git a/src/main/java/detrav/utils/DetravCreativeTab.java b/src/main/java/detrav/utils/DetravCreativeTab.java new file mode 100644 index 0000000000..4550e7ec4b --- /dev/null +++ b/src/main/java/detrav/utils/DetravCreativeTab.java @@ -0,0 +1,51 @@ +package detrav.utils; + +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.init.Items; +import net.minecraft.item.Item; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import detrav.items.DetravMetaGeneratedTool01; + +/** + * Created by wital_000 on 19.03.2016. + */ +public class DetravCreativeTab extends CreativeTabs { + + public DetravCreativeTab() { + super("Detrav Scanner"); + } + + @Override + public Item getTabIconItem() { + return Items.stick; + } + + @Override + @SideOnly(Side.CLIENT) + public void displayAllReleventItems(List p_78018_1_) { + for (Object o : Item.itemRegistry) { + Item item = (Item) o; + + if (item == null) { + continue; + } + + for (CreativeTabs tab : item.getCreativeTabs()) { + if (tab == this) { + item.getSubItems(item, this, p_78018_1_); + if (item instanceof DetravMetaGeneratedTool01) { + ((DetravMetaGeneratedTool01) item).getDetravSubItems(item, this, p_78018_1_); + } + } + } + } + + if (this.func_111225_m() != null) { + this.addEnchantmentBooksToList(p_78018_1_, this.func_111225_m()); + } + } +} diff --git a/src/main/java/detrav/utils/FluidColors.java b/src/main/java/detrav/utils/FluidColors.java new file mode 100644 index 0000000000..3bb52bb76b --- /dev/null +++ b/src/main/java/detrav/utils/FluidColors.java @@ -0,0 +1,135 @@ +package detrav.utils; + +import static detrav.net.ProspectingPacket.fluidColors; + +import java.util.Arrays; +import java.util.Objects; + +import net.minecraftforge.fluids.FluidRegistry; + +import gregtech.api.enums.Materials; + +public class FluidColors { + + public static void makeColors() { + + reFillFluidColors(); + + // ProgressManager.ProgressBar progressBar = ProgressManager.push("Making Fluid Colors", (int) + // (Materials.values().length + + // FluidRegistry.getRegisteredFluids().values().stream().filter(Objects::nonNull).count())); + Arrays.stream(Materials.values()) + .forEach(mat -> { + // progressBar.step(mat.mDefaultLocalName); + if (mat.getSolid(0) != null) fluidColors.putIfAbsent( + mat.getSolid(0) + .getFluidID(), + mat.mRGBa); + if (mat.getGas(0) != null) fluidColors.putIfAbsent( + mat.getGas(0) + .getFluidID(), + mat.mRGBa); + if (mat.getFluid(0) != null) fluidColors.putIfAbsent( + mat.getFluid(0) + .getFluidID(), + mat.mRGBa); + if (mat.getMolten(0) != null) fluidColors.putIfAbsent( + mat.getMolten(0) + .getFluidID(), + mat.mRGBa); + }); + FluidRegistry.getRegisteredFluids() + .values() + .stream() + .filter(Objects::nonNull) + .forEach(fluid -> { + // progressBar.step(fluid.getName()); + fluidColors.putIfAbsent(fluid.getID(), convertColorInt(fluid.getColor())); + }); + // ProgressManager.pop(progressBar); + } + + private static void reFillFluidColors() { + try { + // Should probably be put somewhere else, but I suck at Java + fluidColors.put(Materials.NatruralGas.mGas.getID(), new short[] { 0x00, 0xff, 0xff }); + fluidColors.put(Materials.OilLight.mFluid.getID(), new short[] { 0xff, 0xff, 0x00 }); + fluidColors.put(Materials.OilMedium.mFluid.getID(), new short[] { 0x00, 0xFF, 0x00 }); + fluidColors.put(Materials.OilHeavy.mFluid.getID(), new short[] { 0xFF, 0x00, 0xFF }); + fluidColors.put(Materials.Oil.mFluid.getID(), new short[] { 0x00, 0x00, 0x00 }); + fluidColors.put(Materials.Helium_3.mGas.getID(), new short[] { 0x80, 0x20, 0xe0 }); + fluidColors.put(Materials.SaltWater.mFluid.getID(), new short[] { 0x80, 0xff, 0x80 }); + // fluidColors.put(Materials.Naquadah.getMolten(0).getFluid().getID(), new short[]{0x20, 0x20, 0x20}); + // fluidColors.put(Materials.NaquadahEnriched.getMolten(0).getFluid().getID(), new short[]{0x60, 0x60, + // 0x60}); + fluidColors.put( + Materials.Lead.getMolten(0) + .getFluid() + .getID(), + new short[] { 0xd0, 0xd0, 0xd0 }); + fluidColors.put(Materials.Chlorobenzene.mFluid.getID(), new short[] { 0x40, 0x80, 0x40 }); + fluidColors.put( + FluidRegistry.getFluid("liquid_extra_heavy_oil") + .getID(), + new short[] { 0x00, 0x00, 0x50 }); + fluidColors.put(Materials.Oxygen.mGas.getID(), new short[] { 0x40, 0x40, 0xA0 }); + fluidColors.put(Materials.Nitrogen.mGas.getID(), new short[] { 0x00, 0x80, 0xd0 }); + fluidColors.put(Materials.Methane.mGas.getID(), new short[] { 0x80, 0x20, 0x20 }); + fluidColors.put(Materials.Ethane.mGas.getID(), new short[] { 0x40, 0x80, 0x20 }); + fluidColors.put(Materials.Ethylene.mGas.getID(), new short[] { 0xd0, 0xd0, 0xd0 }); + fluidColors.put(FluidRegistry.LAVA.getID(), new short[] { 0xFF, 0x00, 0x00 }); + fluidColors.put( + FluidRegistry.getFluid("unknowwater") + .getID(), + new short[] { 0x8A, 0x2B, 0xE2 }); + fluidColors.put(Materials.Hydrogen.mGas.getID(), new short[] { 0x32, 0x32, 0xD6 }); + fluidColors.put(Materials.SulfuricAcid.mFluid.getID(), new short[] { 0xFF, 0xB9, 0x0F }); + fluidColors.put(Materials.HydricSulfide.mFluid.getID(), new short[] { 0xFF, 0x8F, 0x43 }); + fluidColors.put(Materials.CarbonMonoxide.mGas.getID(), new short[] { 0x10, 0x4E, 0x8B }); + fluidColors.put(Materials.CarbonDioxide.mGas.getID(), new short[] { 0x69, 0x69, 0x69 }); + fluidColors.put( + FluidRegistry.getFluid("ic2distilledwater") + .getID(), + new short[] { 0x1E, 0x90, 0xFF }); + fluidColors.put(Materials.Deuterium.mGas.getID(), new short[] { 0xFF, 0xE3, 0x9F }); + fluidColors.put( + Materials.Iron.getMolten(0) + .getFluid() + .getID(), + new short[] { 0x8B, 0x88, 0x78 }); + fluidColors.put( + Materials.Tin.getMolten(0) + .getFluid() + .getID(), + new short[] { 0xE7, 0xE7, 0xE4 }); + fluidColors.put( + Materials.Copper.getMolten(0) + .getFluid() + .getID(), + new short[] { 0xFF, 0x7F, 0x24 }); + fluidColors.put( + FluidRegistry.getFluid("fluorine") + .getID(), + new short[] { 0x99, 0xC1, 0xAD }); + fluidColors.put( + FluidRegistry.getFluid("hydrofluoricacid") + .getID(), + new short[] { 0x00, 0xCE, 0xD1 }); + fluidColors.put(Materials.PhosphoricAcid.mFluid.getID(), new short[] { 0xEE, 0x76, 0x00 }); + + // possible nulls + fluidColors.put(Materials.LiquidAir.mFluid.getID(), new short[] { 0x99, 0x99, 0xEA }); + } catch (Exception ignored) {} + /* + * Set set = fluidColors.entrySet(); Iterator iterator = set.iterator(); System.out.println( + * "DETRAV SCANNER DEBUG" ); while(iterator.hasNext()) { Map.Entry mentry = (Map.Entry) iterator.next(); + * System.out.println( "key is: "+ (Integer)mentry.getKey() + " & Value is: " + ((short[])mentry.getValue())[0] + * + " " + ((short[])mentry.getValue())[1] + " " + ((short[])mentry.getValue())[2] ); } + */ + } + + private static short[] convertColorInt(int color) { + return new short[] { (short) (color << 16 & 0xff), (short) (color << 8 & 0xff), (short) (color & 0xff) }; + } + +} diff --git a/src/main/java/detrav/utils/GTppHelper.java b/src/main/java/detrav/utils/GTppHelper.java new file mode 100644 index 0000000000..985ca3386b --- /dev/null +++ b/src/main/java/detrav/utils/GTppHelper.java @@ -0,0 +1,67 @@ +package detrav.utils; + +import java.util.HashMap; + +import net.minecraft.block.Block; + +import gtPlusPlus.core.block.base.BlockBaseOre; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialMisc; +import gtPlusPlus.core.material.MaterialsAlloy; +import gtPlusPlus.core.material.MaterialsElements; +import gtPlusPlus.core.material.MaterialsOres; +import gtPlusPlus.core.material.nuclear.MaterialsFluorides; + +/** + * Created by bartimaeusnek on 19.04.2018. + */ +public class GTppHelper { + + public static final HashMap<Short, Material> decodeoresGTpp = new HashMap<>(); + public static final HashMap<Material, Short> encodeoresGTpp = new HashMap<>(); + + public static void generate_OreIDs() { + short n = 0; + for (; n < MaterialsOres.class.getFields().length; ++n) { + try { + Short i = (short) (n + 1); + Material m = ((Material) MaterialsOres.class.getFields()[n].get(MaterialsOres.class.getFields()[n])); + decodeoresGTpp.put(i, m); + encodeoresGTpp.put(m, i); + } catch (Exception ignored) {} + } + // Manually add ores from other places than the ore class + // Fluorite + decodeoresGTpp.put((short) (++n + 1), MaterialsFluorides.FLUORITE); + encodeoresGTpp.put(MaterialsFluorides.FLUORITE, (short) (n + 1)); + // Rare Earths + decodeoresGTpp.put((short) (++n + 1), MaterialMisc.RARE_EARTH_LOW); + encodeoresGTpp.put(MaterialMisc.RARE_EARTH_LOW, (short) (n + 1)); + decodeoresGTpp.put((short) (++n + 1), MaterialMisc.RARE_EARTH_MID); + encodeoresGTpp.put(MaterialMisc.RARE_EARTH_MID, (short) (n + 1)); + decodeoresGTpp.put((short) (++n + 1), MaterialMisc.RARE_EARTH_HIGH); + encodeoresGTpp.put(MaterialMisc.RARE_EARTH_HIGH, (short) (n + 1)); + // Koboldite + decodeoresGTpp.put((short) (++n + 1), MaterialsAlloy.KOBOLDITE); + encodeoresGTpp.put(MaterialsAlloy.KOBOLDITE, (short) (n + 1)); + // Runite + decodeoresGTpp.put((short) (++n + 1), MaterialsElements.STANDALONE.RUNITE); + encodeoresGTpp.put(MaterialsElements.STANDALONE.RUNITE, (short) (n + 1)); + // Ancient granite + decodeoresGTpp.put((short) (++n + 1), MaterialsElements.STANDALONE.GRANITE); + encodeoresGTpp.put(MaterialsElements.STANDALONE.GRANITE, (short) (n + 1)); + } + + public static boolean isGTppBlock(Block tBlock) { + return tBlock instanceof BlockBaseOre; + } + + public static short getGTppMeta(Block tBlock) { + return (short) (GTppHelper.encodeoresGTpp.get(((BlockBaseOre) tBlock).getMaterialEx()) + 7000); + } + + public static String getGTppVeinName(Block tBlock) { + return tBlock.getLocalizedName(); + } + +} |