mirror of
https://github.com/GTNewHorizons/ForestryMC.git
synced 2026-11-21 04:22:32 +00:00
Moved logic out of Containers, the old filtered slots were not always the same logic as the IInventory. Moved ISidedInventory logic up to TileForestry and use InventoryAdapters to override only the methods we need to. Tested a ton but there will be some new issues given the scope.
246 lines
8.4 KiB
Java
Executable File
246 lines
8.4 KiB
Java
Executable File
/*******************************************************************************
|
|
* Copyright (c) 2011-2014 SirSengir.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the GNU Lesser Public License v3
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.gnu.org/licenses/lgpl-3.0.txt
|
|
*
|
|
* Various Contributors including, but not limited to:
|
|
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
|
|
******************************************************************************/
|
|
package forestry.apiculture.items;
|
|
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import forestry.api.apiculture.IBee;
|
|
import forestry.api.core.ForestryAPI;
|
|
import forestry.api.core.Tabs;
|
|
import forestry.apiculture.render.TextureBiomefinder;
|
|
import forestry.core.EnumErrorCode;
|
|
import forestry.core.config.Config;
|
|
import forestry.core.config.ForestryItem;
|
|
import forestry.core.interfaces.IErrorSource;
|
|
import forestry.core.interfaces.IHintSource;
|
|
import forestry.core.inventory.ItemInventory;
|
|
import forestry.core.items.ItemInventoried;
|
|
import forestry.core.network.GuiId;
|
|
import forestry.core.proxy.Proxies;
|
|
import forestry.core.vect.Vect;
|
|
import forestry.plugins.PluginApiculture;
|
|
import java.util.ArrayList;
|
|
import net.minecraft.client.renderer.texture.IIconRegister;
|
|
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
|
|
import net.minecraft.client.renderer.texture.TextureMap;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.util.ChunkCoordinates;
|
|
import net.minecraft.world.World;
|
|
import net.minecraft.world.biome.BiomeGenBase;
|
|
|
|
public class ItemBiomefinder extends ItemInventoried {
|
|
|
|
public static class BiomefinderInventory extends ItemInventory implements IErrorSource, IHintSource {
|
|
|
|
public ArrayList<Integer> biomesToSearch = new ArrayList<Integer>();
|
|
|
|
private final short energySlot = 2;
|
|
private final short specimenSlot = 0;
|
|
private final short analyzeSlot = 1;
|
|
|
|
public BiomefinderInventory(ItemStack itemstack) {
|
|
super(ItemBiomefinder.class, 3, itemstack);
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbttagcompound) {
|
|
|
|
NBTTagList nbttaglist = new NBTTagList();
|
|
for (int i = 2; i < inventoryStacks.length; i++)
|
|
if (inventoryStacks[i] != null) {
|
|
NBTTagCompound nbttagcompound1 = new NBTTagCompound();
|
|
nbttagcompound1.setByte("Slot", (byte) i);
|
|
inventoryStacks[i].writeToNBT(nbttagcompound1);
|
|
nbttaglist.appendTag(nbttagcompound1);
|
|
}
|
|
nbttagcompound.setTag("Items", nbttaglist);
|
|
|
|
}
|
|
|
|
private boolean isEnergy(ItemStack itemstack) {
|
|
if (itemstack == null || itemstack.stackSize <= 0)
|
|
return false;
|
|
|
|
return ForestryItem.honeyDrop.isItemEqual(itemstack) || ForestryItem.honeydew.isItemEqual(itemstack);
|
|
}
|
|
|
|
private void tryAnalyze() {
|
|
|
|
// Analyzed slot occupied, abort
|
|
if (inventoryStacks[analyzeSlot] != null)
|
|
return;
|
|
|
|
// Source slot to analyze empty
|
|
if (getStackInSlot(specimenSlot) == null)
|
|
return;
|
|
|
|
IBee bee = PluginApiculture.beeInterface.getMember(getStackInSlot(specimenSlot));
|
|
// No bee, abort
|
|
if (bee == null)
|
|
return;
|
|
|
|
// Requires energy
|
|
if (!isEnergy(getStackInSlot(energySlot)))
|
|
return;
|
|
|
|
biomesToSearch = bee.getSuitableBiomeIds();
|
|
|
|
// Decrease energy
|
|
decrStackSize(energySlot, 1);
|
|
|
|
setInventorySlotContents(analyzeSlot, getStackInSlot(specimenSlot));
|
|
setInventorySlotContents(specimenSlot, null);
|
|
}
|
|
|
|
@Override
|
|
public void markDirty() {
|
|
tryAnalyze();
|
|
}
|
|
|
|
// / IHINTSOURCE
|
|
@Override
|
|
public boolean hasHints() {
|
|
return Config.hints.get("habitatlocator") != null && Config.hints.get("habitatlocator").length > 0;
|
|
}
|
|
|
|
@Override
|
|
public String[] getHints() {
|
|
return Config.hints.get("habitatlocator");
|
|
}
|
|
|
|
// / IERRORSOURCE
|
|
@Override
|
|
public boolean throwsErrors() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public EnumErrorCode getErrorState() {
|
|
if (PluginApiculture.beeInterface.isMember(inventoryStacks[specimenSlot]) && !isEnergy(getStackInSlot(energySlot)))
|
|
return EnumErrorCode.NOHONEY;
|
|
|
|
return EnumErrorCode.OK;
|
|
}
|
|
|
|
@Override
|
|
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
|
|
if (slotIndex == energySlot) {
|
|
Item item = itemStack.getItem();
|
|
return item == ForestryItem.honeydew.item() || item == ForestryItem.honeyDrop.item();
|
|
} else if (slotIndex == specimenSlot || slotIndex == analyzeSlot) {
|
|
return PluginApiculture.beeInterface.isMember(itemStack);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
public ItemBiomefinder() {
|
|
super();
|
|
setMaxStackSize(1);
|
|
setCreativeTab(Tabs.tabApiculture);
|
|
}
|
|
|
|
@Override
|
|
public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer) {
|
|
|
|
if (Proxies.common.isSimulating(world))
|
|
entityplayer.openGui(ForestryAPI.instance, GuiId.HabitatLocatorGUI.ordinal(), world, (int) entityplayer.posX, (int) entityplayer.posY,
|
|
(int) entityplayer.posZ);
|
|
|
|
return itemstack;
|
|
}
|
|
|
|
public void startBiomeSearch(World world, EntityPlayer player, ArrayList<Integer> biomesToSearch) {
|
|
|
|
ArrayList<Integer> excludedBiomes = new ArrayList<Integer>();
|
|
excludedBiomes.add(BiomeGenBase.ocean.biomeID);
|
|
excludedBiomes.add(BiomeGenBase.frozenOcean.biomeID);
|
|
excludedBiomes.add(BiomeGenBase.beach.biomeID);
|
|
biomesToSearch.removeAll(excludedBiomes);
|
|
|
|
// If we are in a valid biome, we point to ourself.
|
|
BiomeGenBase biome = world.getBiomeGenForCoords((int) player.posX, (int) player.posZ);
|
|
if (biomesToSearch.contains(biome.biomeID)) {
|
|
Proxies.common.setBiomefinderCoordinates(player, new ChunkCoordinates((int) player.posX, (int) player.posY, (int) player.posZ));
|
|
return;
|
|
}
|
|
|
|
if (Proxies.common.isSimulating(world) && biomesToSearch.size() > 0) {
|
|
ChunkCoordinates target = findNearestBiome(player, biomesToSearch);
|
|
Proxies.common.setBiomefinderCoordinates(player, target);
|
|
}
|
|
|
|
}
|
|
|
|
private ChunkCoordinates findNearestBiome(EntityPlayer player, ArrayList<Integer> biomesToSearch) {
|
|
|
|
int loadChunkDistance = 25;
|
|
ChunkCoordinates coordinates = null;
|
|
Vect pos = new Vect((int) player.posX, (int) player.posY, (int) player.posZ);
|
|
for (int i = 0; i < 100; i++) {
|
|
// Test direction +X
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(10 * i, 0, 0)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
// Test direction +X+Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(10 * i, 0, 10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
// Test direction +X-Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(10 * i, 0, -10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
|
|
// Test direction -X
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(-10 * i, 0, 0)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
// Test direction -X+Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(-10 * i, 0, 10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
// Test direction -X-Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(-10 * i, 0, -10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
|
|
// Test direction +Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(0, 0, 10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
// Test direction -Z
|
|
if ((coordinates = getChunkCoordinates(pos.add(new Vect(0, 0, -10 * i)), player.worldObj, biomesToSearch, i < loadChunkDistance)) != null)
|
|
return coordinates;
|
|
}
|
|
return coordinates;
|
|
}
|
|
|
|
private ChunkCoordinates getChunkCoordinates(Vect pos, World world, ArrayList<Integer> biomesToSearch, boolean loadChunks) {
|
|
|
|
BiomeGenBase biome = world.getBiomeGenForCoords(pos.x, pos.z);
|
|
|
|
if (biomesToSearch.contains(biome.biomeID))
|
|
return new ChunkCoordinates(pos.x, pos.y, pos.z);
|
|
|
|
return null;
|
|
}
|
|
|
|
/* TEXTURES */
|
|
@SideOnly(Side.CLIENT)
|
|
@Override
|
|
public void registerIcons(IIconRegister register) {
|
|
if(register instanceof TextureMap) {
|
|
TextureAtlasSprite texture = new TextureBiomefinder();
|
|
((TextureMap)register).setTextureEntry("forestry:biomefinder", texture);
|
|
itemIcon = texture;
|
|
}
|
|
}
|
|
|
|
}
|