diff --git a/src/main/java/ic2/api/Direction.java b/src/main/java/ic2/api/Direction.java new file mode 100644 index 000000000..ee4f15bad --- /dev/null +++ b/src/main/java/ic2/api/Direction.java @@ -0,0 +1,70 @@ +package ic2.api; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; + +public enum Direction +{ + XN, + XP, + YN, + YP, + ZN, + ZP; + + public static final Direction[] directions; + + public static Direction fromSideValue(final int side) { + return Direction.directions[(side + 2) % 6]; + } + + public static Direction fromEnumFacing(final EnumFacing dir) { + if (dir == null) { + return null; + } + return fromSideValue(dir.getIndex()); + } + + public TileEntity applyToTileEntity(final TileEntity te) { + return this.applyTo(te.getWorld(), te.getPos()); + } + + public TileEntity applyTo(final World world, final BlockPos pos) { + final int[] array; + final int[] coords = array = new int[] { pos.getX(), pos.getY(), pos.getZ() }; + final int n = this.ordinal() / 2; + array[n] += this.getSign(); + BlockPos pos2 = new BlockPos(coords[0], coords[1], coords[2]); + if (world != null && world.isBlockLoaded(pos2)) { + try { + return world.getTileEntity(pos2); + } + catch (Exception e) { + throw new RuntimeException("error getting TileEntity at dim " + world.provider.getDimensionId() + " " + pos2.toString()); + } + } + return null; + } + + public Direction getInverse() { + return Direction.directions[this.ordinal() ^ 0x1]; + } + + public int toSideValue() { + return (this.ordinal() + 4) % 6; + } + + private int getSign() { + return this.ordinal() % 2 * 2 - 1; + } + + public EnumFacing toEnumFacing() { + return EnumFacing.getFront(this.toSideValue()); + } + + static { + directions = values(); + } +} diff --git a/src/main/java/ic2/api/crops/BaseSeed.java b/src/main/java/ic2/api/crops/BaseSeed.java new file mode 100644 index 000000000..d82dd41dd --- /dev/null +++ b/src/main/java/ic2/api/crops/BaseSeed.java @@ -0,0 +1,35 @@ +package ic2.api.crops; + +public class BaseSeed +{ + public final CropCard crop; + @Deprecated + public int id; + public int size; + public int statGrowth; + public int statGain; + public int statResistance; + public int stackSize; + + public BaseSeed(final CropCard crop, final int size, final int statGrowth, final int statGain, final int statResistance, final int stackSize) { + this.crop = crop; + this.id = Crops.instance.getIdFor(crop); + this.size = size; + this.statGrowth = statGrowth; + this.statGain = statGain; + this.statResistance = statResistance; + this.stackSize = stackSize; + } + + public BaseSeed(final int id, final int size, final int statGrowth, final int statGain, final int statResistance, final int stackSize) { + this(getCropFromId(id), size, statGrowth, statGain, statResistance, stackSize); + } + + private static CropCard getCropFromId(final int id) { + final CropCard[] crops = Crops.instance.getCropList(); + if (id < 0 || id >= crops.length) { + return null; + } + return crops[id]; + } +} diff --git a/src/main/java/ic2/api/crops/CropCard.java b/src/main/java/ic2/api/crops/CropCard.java new file mode 100644 index 000000000..10b8284fe --- /dev/null +++ b/src/main/java/ic2/api/crops/CropCard.java @@ -0,0 +1,165 @@ +package ic2.api.crops; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.Loader; +import net.minecraftforge.fml.common.ModContainer; + +public abstract class CropCard +{ + private final String modId; + + public CropCard() { + this.modId = getModId(); + } + + public abstract String name(); + + public String owner() { + return this.modId; + } + + public String displayName() { + return this.name(); + } + + public String discoveredBy() { + return "unknown"; + } + + public String desc(final int i) { + final String[] att = this.attributes(); + if (att == null || att.length == 0) { + return ""; + } + if (i == 0) { + String s = att[0]; + if (att.length >= 2) { + s = s + ", " + att[1]; + if (att.length >= 3) { + s += ","; + } + } + return s; + } + if (att.length < 3) { + return ""; + } + String s = att[2]; + if (att.length >= 4) { + s = s + ", " + att[3]; + } + return s; + } + + public int getrootslength(final ICropTile crop) { + return 1; + } + + public abstract int tier(); + + public abstract int stat(final int p0); + + public abstract String[] attributes(); + + public abstract int maxSize(); + + public int growthDuration(final ICropTile crop) { + return this.tier() * 200; + } + + public abstract boolean canGrow(final ICropTile p0); + + public int weightInfluences(final ICropTile crop, final float humidity, final float nutrients, final float air) { + return (int)(humidity + nutrients + air); + } + + public boolean canCross(final ICropTile crop) { + return crop.getSize() >= 3; + } + + public boolean rightclick(final ICropTile crop, final EntityPlayer player) { + return crop.harvest(true); + } + + public abstract int getOptimalHavestSize(final ICropTile p0); + + public abstract boolean canBeHarvested(final ICropTile p0); + + public float dropGainChance() { + float base = 1.0f; + for (int i = 0; i < this.tier(); ++i) { + base *= 0.95; + } + return base; + } + + public abstract ItemStack getGain(final ICropTile p0); + + public byte getSizeAfterHarvest(final ICropTile crop) { + return 1; + } + + public boolean leftclick(final ICropTile crop, final EntityPlayer player) { + return crop.pick(true); + } + + public float dropSeedChance(final ICropTile crop) { + if (crop.getSize() == 1) { + return 0.0f; + } + float base = 0.5f; + if (crop.getSize() == 2) { + base /= 2.0f; + } + for (int i = 0; i < this.tier(); ++i) { + base *= 0.8; + } + return base; + } + + public ItemStack getSeeds(final ICropTile crop) { + return crop.generateSeeds(crop.getCrop(), crop.getGrowth(), crop.getGain(), crop.getResistance(), crop.getScanLevel()); + } + + public void onNeighbourChange(final ICropTile crop) { + } + + public int emitRedstone(final ICropTile crop) { + return 0; + } + + public void onBlockDestroyed(final ICropTile crop) { + } + + public int getEmittedLight(final ICropTile crop) { + return 0; + } + + public boolean onEntityCollision(final ICropTile crop, final Entity entity) { + return entity instanceof EntityLivingBase && ((EntityLivingBase)entity).isSprinting(); + } + + public void tick(final ICropTile crop) { + } + + public boolean isWeed(final ICropTile crop) { + return crop.getSize() >= 2 && (crop == Crops.weed || crop.getGrowth() >= 24); + } + + @Deprecated + public final int getId() { + return Crops.instance.getIdFor(this); + } + + private static String getModId() { + final ModContainer modContainer = Loader.instance().activeModContainer(); + if (modContainer != null) { + return modContainer.getModId(); + } + assert false; + return "unknown"; + } +} diff --git a/src/main/java/ic2/api/crops/Crops.java b/src/main/java/ic2/api/crops/Crops.java new file mode 100644 index 000000000..f71702a3b --- /dev/null +++ b/src/main/java/ic2/api/crops/Crops.java @@ -0,0 +1,44 @@ +package ic2.api.crops; + +import net.minecraft.item.ItemStack; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraftforge.common.BiomeDictionary; + +import java.util.Collection; + +public abstract class Crops +{ + public static Crops instance; + public static CropCard weed; + + public abstract void addBiomenutrientsBonus(final BiomeDictionary.Type p0, final int p1); + + public abstract void addBiomehumidityBonus(final BiomeDictionary.Type p0, final int p1); + + public abstract int getHumidityBiomeBonus(final BiomeGenBase p0); + + public abstract int getNutrientBiomeBonus(final BiomeGenBase p0); + + public abstract CropCard getCropCard(final String p0, final String p1); + + public abstract CropCard getCropCard(final ItemStack p0); + + public abstract Collection getCrops(); + + @Deprecated + public abstract CropCard[] getCropList(); + + public abstract short registerCrop(final CropCard p0); + + public abstract boolean registerCrop(final CropCard p0, final int p1); + + @Deprecated + public abstract boolean registerBaseSeed(final ItemStack p0, final int p1, final int p2, final int p3, final int p4, final int p5); + + public abstract boolean registerBaseSeed(final ItemStack p0, final CropCard p1, final int p2, final int p3, final int p4, final int p5); + + public abstract BaseSeed getBaseSeed(final ItemStack p0); + + @Deprecated + public abstract int getIdFor(final CropCard p0); +} diff --git a/src/main/java/ic2/api/crops/ICropTile.java b/src/main/java/ic2/api/crops/ICropTile.java new file mode 100644 index 000000000..6efa70d6f --- /dev/null +++ b/src/main/java/ic2/api/crops/ICropTile.java @@ -0,0 +1,83 @@ +package ic2.api.crops; + +import net.minecraft.nbt.*; +import net.minecraft.world.*; +import net.minecraft.util.*; +import net.minecraft.item.*; +import net.minecraft.block.*; + +public interface ICropTile +{ + CropCard getCrop(); + + void setCrop(CropCard p0); + + @Deprecated + short getID(); + + @Deprecated + void setID(short p0); + + byte getSize(); + + void setSize(byte p0); + + byte getGrowth(); + + void setGrowth(byte p0); + + byte getGain(); + + void setGain(byte p0); + + byte getResistance(); + + void setResistance(byte p0); + + byte getScanLevel(); + + void setScanLevel(byte p0); + + NBTTagCompound getCustomData(); + + int getNutrientStorage(); + + void setNutrientStorage(int p0); + + int getHydrationStorage(); + + void setHydrationStorage(int p0); + + int getWeedExStorage(); + + void setWeedExStorage(int p0); + + byte getHumidity(); + + byte getNutrients(); + + byte getAirQuality(); + + World getWorld(); + + BlockPos getLocation(); + + int getLightLevel(); + + boolean pick(boolean p0); + + boolean harvest(boolean p0); + + ItemStack[] harvest_automated(boolean p0); + + void reset(); + + void updateState(); + + boolean isBlockBelow(Block p0); + + ItemStack generateSeeds(CropCard p0, byte p1, byte p2, byte p3, byte p4); + + @Deprecated + ItemStack generateSeeds(short p0, byte p1, byte p2, byte p3, byte p4); +} diff --git a/src/main/java/ic2/api/crops/package-info.java b/src/main/java/ic2/api/crops/package-info.java new file mode 100644 index 000000000..220a16030 --- /dev/null +++ b/src/main/java/ic2/api/crops/package-info.java @@ -0,0 +1,6 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.crops; + +import net.minecraftforge.fml.common.*; + + diff --git a/src/main/java/ic2/api/energy/EnergyNet.java b/src/main/java/ic2/api/energy/EnergyNet.java new file mode 100644 index 000000000..e0414cf0d --- /dev/null +++ b/src/main/java/ic2/api/energy/EnergyNet.java @@ -0,0 +1,6 @@ +package ic2.api.energy; + +public final class EnergyNet +{ + public static IEnergyNet instance; +} diff --git a/src/main/java/ic2/api/energy/IEnergyNet.java b/src/main/java/ic2/api/energy/IEnergyNet.java new file mode 100644 index 000000000..274b0bb32 --- /dev/null +++ b/src/main/java/ic2/api/energy/IEnergyNet.java @@ -0,0 +1,25 @@ +package ic2.api.energy; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; + +public interface IEnergyNet +{ + TileEntity getTileEntity(World p0, BlockPos pos); + + TileEntity getNeighbor(TileEntity p0, EnumFacing p1); + + @Deprecated + double getTotalEnergyEmitted(TileEntity p0); + + @Deprecated + double getTotalEnergySunken(TileEntity p0); + + NodeStats getNodeStats(TileEntity p0); + + double getPowerFromTier(int p0); + + int getTierFromPower(double p0); +} diff --git a/src/main/java/ic2/api/energy/IPacketEnergyNet.java b/src/main/java/ic2/api/energy/IPacketEnergyNet.java new file mode 100644 index 000000000..65d18881c --- /dev/null +++ b/src/main/java/ic2/api/energy/IPacketEnergyNet.java @@ -0,0 +1,11 @@ +package ic2.api.energy; + +import net.minecraft.tileentity.*; +import java.util.*; + +public interface IPacketEnergyNet extends IEnergyNet +{ + List getSendedPackets(TileEntity p0); + + List getTotalSendedPackets(TileEntity p0); +} diff --git a/src/main/java/ic2/api/energy/NodeStats.java b/src/main/java/ic2/api/energy/NodeStats.java new file mode 100644 index 000000000..cf3533757 --- /dev/null +++ b/src/main/java/ic2/api/energy/NodeStats.java @@ -0,0 +1,26 @@ +package ic2.api.energy; + +public class NodeStats +{ + protected double energyIn; + protected double energyOut; + protected double voltage; + + public NodeStats(final double energyIn, final double energyOut, final double voltage) { + this.energyIn = energyIn; + this.energyOut = energyOut; + this.voltage = voltage; + } + + public double getEnergyIn() { + return this.energyIn; + } + + public double getEnergyOut() { + return this.energyOut; + } + + public double getVoltage() { + return this.voltage; + } +} diff --git a/src/main/java/ic2/api/energy/PacketStat.java b/src/main/java/ic2/api/energy/PacketStat.java new file mode 100644 index 000000000..b1047d9a6 --- /dev/null +++ b/src/main/java/ic2/api/energy/PacketStat.java @@ -0,0 +1,31 @@ +package ic2.api.energy; + +public class PacketStat implements Comparable +{ + public final int energy; + public final long count; + + public PacketStat(final int par1, final long par2) { + this.energy = par1; + this.count = par2; + } + + public long getPacketCount() { + return this.count; + } + + public int getPacketEnergy() { + return this.energy; + } + + @Override + public int compareTo(final PacketStat o) { + if (o.energy < this.energy) { + return 1; + } + if (o.energy > this.energy) { + return -1; + } + return 0; + } +} diff --git a/src/main/java/ic2/api/energy/event/EnergyTileEvent.java b/src/main/java/ic2/api/energy/event/EnergyTileEvent.java new file mode 100644 index 000000000..c168fb694 --- /dev/null +++ b/src/main/java/ic2/api/energy/event/EnergyTileEvent.java @@ -0,0 +1,18 @@ +package ic2.api.energy.event; + +import net.minecraftforge.event.world.*; +import ic2.api.energy.tile.*; +import net.minecraft.tileentity.*; + +public class EnergyTileEvent extends WorldEvent +{ + public final IEnergyTile energyTile; + + public EnergyTileEvent(final IEnergyTile energyTile1) { + super(((TileEntity)energyTile1).getWorld()); + if (this.world == null) { + throw new NullPointerException("world is null"); + } + this.energyTile = energyTile1; + } +} diff --git a/src/main/java/ic2/api/energy/event/EnergyTileLoadEvent.java b/src/main/java/ic2/api/energy/event/EnergyTileLoadEvent.java new file mode 100644 index 000000000..3615f9f67 --- /dev/null +++ b/src/main/java/ic2/api/energy/event/EnergyTileLoadEvent.java @@ -0,0 +1,10 @@ +package ic2.api.energy.event; + +import ic2.api.energy.tile.*; + +public class EnergyTileLoadEvent extends EnergyTileEvent +{ + public EnergyTileLoadEvent(final IEnergyTile energyTile1) { + super(energyTile1); + } +} diff --git a/src/main/java/ic2/api/energy/event/EnergyTileUnloadEvent.java b/src/main/java/ic2/api/energy/event/EnergyTileUnloadEvent.java new file mode 100644 index 000000000..2a646ac62 --- /dev/null +++ b/src/main/java/ic2/api/energy/event/EnergyTileUnloadEvent.java @@ -0,0 +1,10 @@ +package ic2.api.energy.event; + +import ic2.api.energy.tile.*; + +public class EnergyTileUnloadEvent extends EnergyTileEvent +{ + public EnergyTileUnloadEvent(final IEnergyTile energyTile1) { + super(energyTile1); + } +} diff --git a/src/main/java/ic2/api/energy/event/package-info.java b/src/main/java/ic2/api/energy/event/package-info.java new file mode 100644 index 000000000..0b8ec046e --- /dev/null +++ b/src/main/java/ic2/api/energy/event/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.energy.event; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/energy/package-info.java b/src/main/java/ic2/api/energy/package-info.java new file mode 100644 index 000000000..85481e5af --- /dev/null +++ b/src/main/java/ic2/api/energy/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.energy; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/energy/prefab/BasicSink.java b/src/main/java/ic2/api/energy/prefab/BasicSink.java new file mode 100644 index 000000000..4d0ef113d --- /dev/null +++ b/src/main/java/ic2/api/energy/prefab/BasicSink.java @@ -0,0 +1,167 @@ +package ic2.api.energy.prefab; + +import net.minecraft.util.ITickable; +import net.minecraft.tileentity.*; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.fml.common.*; +import ic2.api.info.*; +import net.minecraftforge.common.*; +import ic2.api.energy.tile.*; +import net.minecraftforge.fml.common.eventhandler.*; +import ic2.api.energy.event.*; +import net.minecraft.nbt.*; +import net.minecraft.item.*; +import ic2.api.item.*; + +public class BasicSink extends TileEntity implements IEnergySink, ITickable +{ + public final TileEntity parent; + protected int capacity; + protected int tier; + protected double energyStored; + protected boolean addedToEnet; + + public BasicSink(final TileEntity parent1, final int capacity1, final int tier1) { + this.parent = parent1; + this.capacity = capacity1; + this.tier = tier1; + } + + @Override + public void update() { + if (!this.addedToEnet) { + this.onLoaded(); + } + } + + public void onLoaded() { + if (!this.addedToEnet && !FMLCommonHandler.instance().getEffectiveSide().isClient() && Info.isIc2Available()) { + this.worldObj = this.parent.getWorld(); + this.pos = this.parent.getPos(); + MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this)); + this.addedToEnet = true; + } + } + + public void invalidate() { + super.invalidate(); + this.onChunkUnload(); + } + + public void onChunkUnload() { + if (this.addedToEnet && Info.isIc2Available()) { + MinecraftForge.EVENT_BUS.post((Event)new EnergyTileUnloadEvent(this)); + this.addedToEnet = false; + } + } + + public void readFromNBT(final NBTTagCompound tag) { + super.readFromNBT(tag); + final NBTTagCompound data = tag.getCompoundTag("IC2BasicSink"); + this.energyStored = data.getDouble("energy"); + } + + public void writeToNBT(final NBTTagCompound tag) { + try { + super.writeToNBT(tag); + } + catch (RuntimeException ex) {} + final NBTTagCompound data = new NBTTagCompound(); + data.setDouble("energy", this.energyStored); + tag.setTag("IC2BasicSink", (NBTBase)data); + } + + public int getCapacity() { + return this.capacity; + } + + public void setCapacity(final int capacity1) { + this.capacity = capacity1; + } + + public int getTier() { + return this.tier; + } + + public void setTier(final int tier1) { + this.tier = tier1; + } + + public double getEnergyStored() { + return this.energyStored; + } + + public void setEnergyStored(final double amount) { + this.energyStored = amount; + } + + public boolean canUseEnergy(final double amount) { + return this.energyStored >= amount; + } + + public boolean useEnergy(final double amount) { + if (this.canUseEnergy(amount) && !FMLCommonHandler.instance().getEffectiveSide().isClient()) { + this.energyStored -= amount; + return true; + } + return false; + } + + public boolean discharge(final ItemStack stack, final int limit) { + if (stack == null || !Info.isIc2Available()) { + return false; + } + double amount = this.capacity - this.energyStored; + if (amount <= 0.0) { + return false; + } + if (limit > 0 && limit < amount) { + amount = limit; + } + amount = ElectricItem.manager.discharge(stack, amount, this.tier, limit > 0, true, false); + this.energyStored += amount; + return amount > 0.0; + } + + @Deprecated + public void onUpdateEntity() { + this.update(); + } + + @Deprecated + public void onInvalidate() { + this.invalidate(); + } + + @Deprecated + public void onOnChunkUnload() { + this.onChunkUnload(); + } + + @Deprecated + public void onReadFromNbt(final NBTTagCompound tag) { + this.readFromNBT(tag); + } + + @Deprecated + public void onWriteToNbt(final NBTTagCompound tag) { + this.writeToNBT(tag); + } + + public boolean acceptsEnergyFrom(final TileEntity emitter, final EnumFacing direction) { + return true; + } + + public double getDemandedEnergy() { + return Math.max(0.0, this.capacity - this.energyStored); + } + + public double injectEnergy(final EnumFacing directionFrom, final double amount, final double voltage) { + this.energyStored += amount; + return 0.0; + } + + public int getSinkTier() { + return this.tier; + } +} diff --git a/src/main/java/ic2/api/energy/prefab/BasicSource.java b/src/main/java/ic2/api/energy/prefab/BasicSource.java new file mode 100644 index 000000000..78b13569a --- /dev/null +++ b/src/main/java/ic2/api/energy/prefab/BasicSource.java @@ -0,0 +1,174 @@ +package ic2.api.energy.prefab; + +import net.minecraft.util.ITickable; +import net.minecraft.tileentity.*; +import ic2.api.energy.*; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.fml.common.*; +import ic2.api.info.*; +import net.minecraftforge.common.*; +import ic2.api.energy.tile.*; +import net.minecraftforge.fml.common.eventhandler.*; +import ic2.api.energy.event.*; +import net.minecraft.nbt.*; +import net.minecraft.item.*; +import ic2.api.item.*; + +public class BasicSource extends TileEntity implements IEnergySource, ITickable +{ + public final TileEntity parent; + protected double capacity; + protected int tier; + protected double power; + protected double energyStored; + protected boolean addedToEnet; + + public BasicSource(final TileEntity parent1, final double capacity1, final int tier1) { + final double power = EnergyNet.instance.getPowerFromTier(tier1); + this.parent = parent1; + this.capacity = ((capacity1 < power) ? power : capacity1); + this.tier = tier1; + this.power = power; + } + + @Override + public void update() { + if (!this.addedToEnet) { + this.onLoaded(); + } + } + + public void onLoaded() { + if (!this.addedToEnet && !FMLCommonHandler.instance().getEffectiveSide().isClient() && Info.isIc2Available()) { + this.worldObj = this.parent.getWorld(); + this.pos = this.parent.getPos(); + MinecraftForge.EVENT_BUS.post((Event)new EnergyTileLoadEvent(this)); + this.addedToEnet = true; + } + } + + public void invalidate() { + super.invalidate(); + this.onChunkUnload(); + } + + public void onChunkUnload() { + if (this.addedToEnet && Info.isIc2Available()) { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); + this.addedToEnet = false; + } + } + + public void readFromNBT(final NBTTagCompound tag) { + super.readFromNBT(tag); + final NBTTagCompound data = tag.getCompoundTag("IC2BasicSource"); + this.energyStored = data.getDouble("energy"); + } + + public void writeToNBT(final NBTTagCompound tag) { + try { + super.writeToNBT(tag); + } + catch (RuntimeException ex) {} + final NBTTagCompound data = new NBTTagCompound(); + data.setDouble("energy", this.energyStored); + tag.setTag("IC2BasicSource", (NBTBase)data); + } + + public double getCapacity() { + return this.capacity; + } + + public void setCapacity(double capacity1) { + if (capacity1 < this.power) { + capacity1 = this.power; + } + this.capacity = capacity1; + } + + public int getTier() { + return this.tier; + } + + public void setTier(final int tier1) { + final double power = EnergyNet.instance.getPowerFromTier(tier1); + if (this.capacity < power) { + this.capacity = power; + } + this.tier = tier1; + this.power = power; + } + + public double getEnergyStored() { + return this.energyStored; + } + + public void setEnergyStored(final double amount) { + this.energyStored = amount; + } + + public double getFreeCapacity() { + return this.capacity - this.energyStored; + } + + public double addEnergy(double amount) { + if (FMLCommonHandler.instance().getEffectiveSide().isClient()) { + return 0.0; + } + if (amount > this.capacity - this.energyStored) { + amount = this.capacity - this.energyStored; + } + this.energyStored += amount; + return amount; + } + + public boolean charge(final ItemStack stack) { + if (stack == null || !Info.isIc2Available()) { + return false; + } + final double amount = ElectricItem.manager.charge(stack, this.energyStored, this.tier, false, false); + this.energyStored -= amount; + return amount > 0.0; + } + + @Deprecated + public void onUpdateEntity() { + this.update(); + } + + @Deprecated + public void onInvalidate() { + this.invalidate(); + } + + @Deprecated + public void onOnChunkUnload() { + this.onChunkUnload(); + } + + @Deprecated + public void onReadFromNbt(final NBTTagCompound tag) { + this.readFromNBT(tag); + } + + @Deprecated + public void onWriteToNbt(final NBTTagCompound tag) { + this.writeToNBT(tag); + } + + public boolean emitsEnergyTo(final TileEntity receiver, final EnumFacing direction) { + return true; + } + + public double getOfferedEnergy() { + return Math.min(this.energyStored, this.power); + } + + public void drawEnergy(final double amount) { + this.energyStored -= amount; + } + + public int getSourceTier() { + return this.tier; + } +} diff --git a/src/main/java/ic2/api/energy/prefab/package-info.java b/src/main/java/ic2/api/energy/prefab/package-info.java new file mode 100644 index 000000000..da949823e --- /dev/null +++ b/src/main/java/ic2/api/energy/prefab/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.energy.prefab; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/energy/tile/IEnergyAcceptor.java b/src/main/java/ic2/api/energy/tile/IEnergyAcceptor.java new file mode 100644 index 000000000..cfbaf8fa2 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergyAcceptor.java @@ -0,0 +1,9 @@ +package ic2.api.energy.tile; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; + +public interface IEnergyAcceptor extends IEnergyTile +{ + boolean acceptsEnergyFrom(TileEntity p0, EnumFacing p1); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergyConductor.java b/src/main/java/ic2/api/energy/tile/IEnergyConductor.java new file mode 100644 index 000000000..79fb969c1 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergyConductor.java @@ -0,0 +1,16 @@ +package ic2.api.energy.tile; + +public interface IEnergyConductor extends IEnergyAcceptor, IEnergyEmitter +{ + double getConductionLoss(); + + double getInsulationEnergyAbsorption(); + + double getInsulationBreakdownEnergy(); + + double getConductorBreakdownEnergy(); + + void removeInsulation(); + + void removeConductor(); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergyConductorColored.java b/src/main/java/ic2/api/energy/tile/IEnergyConductorColored.java new file mode 100644 index 000000000..bd254a61f --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergyConductorColored.java @@ -0,0 +1,6 @@ +package ic2.api.energy.tile; + +public interface IEnergyConductorColored extends IEnergyConductor +{ + int getConductorColor(); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergyEmitter.java b/src/main/java/ic2/api/energy/tile/IEnergyEmitter.java new file mode 100644 index 000000000..e91cb0672 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergyEmitter.java @@ -0,0 +1,9 @@ +package ic2.api.energy.tile; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; + +public interface IEnergyEmitter extends IEnergyTile +{ + boolean emitsEnergyTo(TileEntity p0, EnumFacing p1); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergySink.java b/src/main/java/ic2/api/energy/tile/IEnergySink.java new file mode 100644 index 000000000..b3e7597f7 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergySink.java @@ -0,0 +1,12 @@ +package ic2.api.energy.tile; + +import net.minecraft.util.EnumFacing; + +public interface IEnergySink extends IEnergyAcceptor +{ + double getDemandedEnergy(); + + int getSinkTier(); + + double injectEnergy(EnumFacing p0, double p1, double p2); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergySource.java b/src/main/java/ic2/api/energy/tile/IEnergySource.java new file mode 100644 index 000000000..b8b947fba --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergySource.java @@ -0,0 +1,10 @@ +package ic2.api.energy.tile; + +public interface IEnergySource extends IEnergyEmitter +{ + double getOfferedEnergy(); + + void drawEnergy(double p0); + + int getSourceTier(); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergySourceInfo.java b/src/main/java/ic2/api/energy/tile/IEnergySourceInfo.java new file mode 100644 index 000000000..4b2cd9646 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergySourceInfo.java @@ -0,0 +1,6 @@ +package ic2.api.energy.tile; + +public interface IEnergySourceInfo extends IEnergySource +{ + int getMaxEnergyAmount(); +} diff --git a/src/main/java/ic2/api/energy/tile/IEnergyTile.java b/src/main/java/ic2/api/energy/tile/IEnergyTile.java new file mode 100644 index 000000000..b146e0fee --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IEnergyTile.java @@ -0,0 +1,5 @@ +package ic2.api.energy.tile; + +public interface IEnergyTile +{ +} diff --git a/src/main/java/ic2/api/energy/tile/IHeatSource.java b/src/main/java/ic2/api/energy/tile/IHeatSource.java new file mode 100644 index 000000000..e826482ec --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IHeatSource.java @@ -0,0 +1,10 @@ +package ic2.api.energy.tile; + +import net.minecraft.util.EnumFacing; + +public interface IHeatSource +{ + int maxrequestHeatTick(EnumFacing p0); + + int requestHeat(EnumFacing p0, int p1); +} diff --git a/src/main/java/ic2/api/energy/tile/IKineticSource.java b/src/main/java/ic2/api/energy/tile/IKineticSource.java new file mode 100644 index 000000000..150ddde00 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IKineticSource.java @@ -0,0 +1,10 @@ +package ic2.api.energy.tile; + +import net.minecraft.util.EnumFacing; + +public interface IKineticSource +{ + int maxrequestkineticenergyTick(EnumFacing p0); + + int requestkineticenergy(EnumFacing p0, int p1); +} diff --git a/src/main/java/ic2/api/energy/tile/IMetaDelegate.java b/src/main/java/ic2/api/energy/tile/IMetaDelegate.java new file mode 100644 index 000000000..fed7093c5 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IMetaDelegate.java @@ -0,0 +1,9 @@ +package ic2.api.energy.tile; + +import java.util.*; +import net.minecraft.tileentity.*; + +public interface IMetaDelegate extends IEnergyTile +{ + List getSubTiles(); +} diff --git a/src/main/java/ic2/api/energy/tile/IMultiEnergySource.java b/src/main/java/ic2/api/energy/tile/IMultiEnergySource.java new file mode 100644 index 000000000..482a6b772 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/IMultiEnergySource.java @@ -0,0 +1,8 @@ +package ic2.api.energy.tile; + +public interface IMultiEnergySource extends IEnergySource +{ + boolean sendMultibleEnergyPackets(); + + int getMultibleEnergyPacketAmount(); +} diff --git a/src/main/java/ic2/api/energy/tile/package-info.java b/src/main/java/ic2/api/energy/tile/package-info.java new file mode 100644 index 000000000..4cfb0c6e3 --- /dev/null +++ b/src/main/java/ic2/api/energy/tile/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.energy.tile; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/event/ExplosionEvent.java b/src/main/java/ic2/api/event/ExplosionEvent.java new file mode 100644 index 000000000..d7eb305bb --- /dev/null +++ b/src/main/java/ic2/api/event/ExplosionEvent.java @@ -0,0 +1,31 @@ +package ic2.api.event; + +import net.minecraftforge.event.world.*; +import net.minecraftforge.fml.common.eventhandler.*; +import net.minecraft.entity.*; +import net.minecraft.world.*; + +@Cancelable +public class ExplosionEvent extends WorldEvent +{ + public final Entity entity; + public double x; + public double y; + public double z; + public double power; + public final EntityLivingBase igniter; + public final int radiationRange; + public final double rangeLimit; + + public ExplosionEvent(final World world, final Entity entity, final double x, final double y, final double z, final double power, final EntityLivingBase igniter, final int radiationRange, final double rangeLimit) { + super(world); + this.entity = entity; + this.x = x; + this.y = y; + this.z = z; + this.power = power; + this.igniter = igniter; + this.radiationRange = radiationRange; + this.rangeLimit = rangeLimit; + } +} diff --git a/src/main/java/ic2/api/event/FoamEvent.java b/src/main/java/ic2/api/event/FoamEvent.java new file mode 100644 index 000000000..461244605 --- /dev/null +++ b/src/main/java/ic2/api/event/FoamEvent.java @@ -0,0 +1,32 @@ +package ic2.api.event; + +import net.minecraft.util.BlockPos; +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.common.eventhandler.Cancelable; + +public class FoamEvent extends WorldEvent +{ + public BlockPos pos; + + public FoamEvent(final World world, final BlockPos pos) { + super(world); + this.pos = pos; + } + + @Cancelable + public static class Check extends FoamEvent + { + public Check(final World world, final BlockPos pos) { + super(world, pos); + } + } + + @Cancelable + public static class Foam extends FoamEvent + { + public Foam(final World world, final BlockPos pos) { + super(world, pos); + } + } +} diff --git a/src/main/java/ic2/api/event/LaserEvent.java b/src/main/java/ic2/api/event/LaserEvent.java new file mode 100644 index 000000000..9167f3780 --- /dev/null +++ b/src/main/java/ic2/api/event/LaserEvent.java @@ -0,0 +1,85 @@ +package ic2.api.event; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.common.eventhandler.Cancelable; + +@Cancelable +public class LaserEvent extends WorldEvent +{ + public final Entity lasershot; + public EntityLivingBase owner; + public float range; + public float power; + public int blockBreaks; + public boolean explosive; + public boolean smelt; + + public LaserEvent(final World world1, final Entity lasershot1, final EntityLivingBase owner1, final float range1, final float power1, final int blockBreaks1, final boolean explosive1, final boolean smelt1) { + super(world1); + this.lasershot = lasershot1; + this.owner = owner1; + this.range = range1; + this.power = power1; + this.blockBreaks = blockBreaks1; + this.explosive = explosive1; + this.smelt = smelt1; + } + + public static class LaserShootEvent extends LaserEvent + { + ItemStack laseritem; + + public LaserShootEvent(final World world1, final Entity lasershot1, final EntityLivingBase owner1, final float range1, final float power1, final int blockBreaks1, final boolean explosive1, final boolean smelt1, final ItemStack laseritem1) { + super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1); + this.laseritem = laseritem1; + } + } + + public static class LaserExplodesEvent extends LaserEvent + { + public float explosionpower; + public float explosiondroprate; + public float explosionentitydamage; + + public LaserExplodesEvent(final World world1, final Entity lasershot1, final EntityLivingBase owner1, final float range1, final float power1, final int blockBreaks1, final boolean explosive1, final boolean smelt1, final float explosionpower1, final float explosiondroprate1, final float explosionentitydamage1) { + super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1); + this.explosionpower = explosionpower1; + this.explosiondroprate = explosiondroprate1; + this.explosionentitydamage = explosionentitydamage1; + } + } + + public static class LaserHitsBlockEvent extends LaserEvent + { + public BlockPos pos; + public EnumFacing side; + public boolean removeBlock; + public boolean dropBlock; + public float dropChance; + + public LaserHitsBlockEvent(final World world1, final Entity lasershot1, final EntityLivingBase owner1, final float range1, final float power1, final int blockBreaks1, final boolean explosive1, final boolean smelt1, final BlockPos pos, final EnumFacing side1, final float dropChance1, final boolean removeBlock1, final boolean dropBlock1) { + super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1); + this.pos = pos; + this.side = side1; + this.removeBlock = removeBlock1; + this.dropBlock = dropBlock1; + this.dropChance = dropChance1; + } + } + + public static class LaserHitsEntityEvent extends LaserEvent + { + public Entity hitentity; + + public LaserHitsEntityEvent(final World world1, final Entity lasershot1, final EntityLivingBase owner1, final float range1, final float power1, final int blockBreaks1, final boolean explosive1, final boolean smelt1, final Entity hitentity1) { + super(world1, lasershot1, owner1, range1, power1, blockBreaks1, explosive1, smelt1); + this.hitentity = hitentity1; + } + } +} diff --git a/src/main/java/ic2/api/event/PaintEvent.java b/src/main/java/ic2/api/event/PaintEvent.java new file mode 100644 index 000000000..094a8d168 --- /dev/null +++ b/src/main/java/ic2/api/event/PaintEvent.java @@ -0,0 +1,25 @@ +package ic2.api.event; + +import net.minecraft.item.EnumDyeColor; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.common.eventhandler.Cancelable; + +@Cancelable +public class PaintEvent extends WorldEvent +{ + public final BlockPos pos; + public final EnumFacing side; + public final EnumDyeColor color; + public boolean painted; + + public PaintEvent(final World world1, final BlockPos pos, final EnumFacing side1, final EnumDyeColor color1) { + super(world1); + this.painted = false; + this.pos = pos; + this.side = side1; + this.color = color1; + } +} diff --git a/src/main/java/ic2/api/event/RetextureEvent.java b/src/main/java/ic2/api/event/RetextureEvent.java new file mode 100644 index 000000000..59b84c23b --- /dev/null +++ b/src/main/java/ic2/api/event/RetextureEvent.java @@ -0,0 +1,27 @@ +package ic2.api.event; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.common.eventhandler.Cancelable; + +@Cancelable +public class RetextureEvent extends WorldEvent +{ + public final BlockPos pos; + public final EnumFacing side; + public final IBlockState referencedState; + public final EnumFacing referencedSide; + public boolean applied; + + public RetextureEvent(final World world1, final BlockPos pos, final EnumFacing side1, final IBlockState state, final EnumFacing referencedSide1) { + super(world1); + this.applied = false; + this.pos = pos; + this.side = side1; + this.referencedState = state; + this.referencedSide = referencedSide1; + } +} diff --git a/src/main/java/ic2/api/event/package-info.java b/src/main/java/ic2/api/event/package-info.java new file mode 100644 index 000000000..8202bfdae --- /dev/null +++ b/src/main/java/ic2/api/event/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.event; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/event/recipe/CannerRecipe.java b/src/main/java/ic2/api/event/recipe/CannerRecipe.java new file mode 100644 index 000000000..d078be7a3 --- /dev/null +++ b/src/main/java/ic2/api/event/recipe/CannerRecipe.java @@ -0,0 +1,38 @@ +package ic2.api.event.recipe; + +import net.minecraft.item.*; + +public abstract class CannerRecipe extends RecipeEvent +{ + int fuel; + + public CannerRecipe(final ItemStack input, final int fuel) { + super(input, input); + this.fuel = fuel; + } + + public int getFuelValue() { + return this.fuel; + } + + public static class FuelValue extends CannerRecipe + { + public FuelValue(final ItemStack input, final int fuel) { + super(input, fuel); + } + } + + public static class FuelMultiplier extends CannerRecipe + { + public FuelMultiplier(final ItemStack input, final int percentage) { + super(input, percentage); + } + } + + public static class FoodEffect extends CannerRecipe + { + public FoodEffect(final ItemStack input, final int meta) { + super(input, meta); + } + } +} diff --git a/src/main/java/ic2/api/event/recipe/ElectrolyzerRecipeEvent.java b/src/main/java/ic2/api/event/recipe/ElectrolyzerRecipeEvent.java new file mode 100644 index 000000000..fe757689a --- /dev/null +++ b/src/main/java/ic2/api/event/recipe/ElectrolyzerRecipeEvent.java @@ -0,0 +1,17 @@ +package ic2.api.event.recipe; + +import net.minecraft.item.*; + +public class ElectrolyzerRecipeEvent extends RecipeEvent +{ + public final int energy; + public final boolean charge; + public final boolean discharge; + + public ElectrolyzerRecipeEvent(final ItemStack par1, final ItemStack par2, final int par3, final boolean par4, final boolean par5) { + super(par1, par2); + this.energy = par3; + this.charge = par4; + this.discharge = par5; + } +} diff --git a/src/main/java/ic2/api/event/recipe/RecipeEvent.java b/src/main/java/ic2/api/event/recipe/RecipeEvent.java new file mode 100644 index 000000000..26dfa4318 --- /dev/null +++ b/src/main/java/ic2/api/event/recipe/RecipeEvent.java @@ -0,0 +1,24 @@ +package ic2.api.event.recipe; + +import net.minecraftforge.fml.common.eventhandler.*; +import net.minecraft.item.*; + +@Cancelable +public class RecipeEvent extends Event +{ + final ItemStack input; + final ItemStack output; + + public RecipeEvent(final ItemStack input, final ItemStack output) { + this.input = input; + this.output = output; + } + + public final ItemStack getInput() { + return this.input.copy(); + } + + public final ItemStack getOutput() { + return this.output.copy(); + } +} diff --git a/src/main/java/ic2/api/info/IC2Classic.java b/src/main/java/ic2/api/info/IC2Classic.java new file mode 100644 index 000000000..de759f9b2 --- /dev/null +++ b/src/main/java/ic2/api/info/IC2Classic.java @@ -0,0 +1,68 @@ +package ic2.api.info; + +import net.minecraftforge.fml.common.*; + +public class IC2Classic +{ + public static IWindTicker windNetwork; + private static IC2Type ic2; + + public static IC2Type getLoadedIC2Type() { + if (IC2Classic.ic2 == IC2Type.NeedLoad) { + updateState(); + } + return IC2Classic.ic2; + } + + public static boolean isIc2ExpLoaded() { + if (IC2Classic.ic2 == IC2Type.NeedLoad) { + updateState(); + } + return IC2Classic.ic2 == IC2Type.Experimental; + } + + public static boolean isIc2ClassicLoaded() { + if (IC2Classic.ic2 == IC2Type.NeedLoad) { + updateState(); + } + return IC2Classic.ic2 == IC2Type.SpeigersClassic; + } + + public static IWindTicker getWindNetwork() { + return IC2Classic.windNetwork; + } + + public static boolean enabledCustoWindNetwork() { + return IC2Classic.windNetwork != null; + } + + static void updateState() { + if (Loader.isModLoaded("IC2-Classic")) { + IC2Classic.ic2 = IC2Type.ImmibisClassic; + return; + } + if (Loader.isModLoaded("IC2")) { + if (Loader.isModLoaded("IC2-Classic-Spmod")) { + IC2Classic.ic2 = IC2Type.SpeigersClassic; + return; + } + IC2Classic.ic2 = IC2Type.Experimental; + } + else { + IC2Classic.ic2 = IC2Type.None; + } + } + + static { + IC2Classic.ic2 = IC2Type.NeedLoad; + } + + public enum IC2Type + { + NeedLoad, + Experimental, + SpeigersClassic, + ImmibisClassic, + None; + } +} diff --git a/src/main/java/ic2/api/info/IEnergyValueProvider.java b/src/main/java/ic2/api/info/IEnergyValueProvider.java new file mode 100644 index 000000000..bf3af30bf --- /dev/null +++ b/src/main/java/ic2/api/info/IEnergyValueProvider.java @@ -0,0 +1,8 @@ +package ic2.api.info; + +import net.minecraft.item.*; + +public interface IEnergyValueProvider +{ + double getEnergyValue(ItemStack p0); +} diff --git a/src/main/java/ic2/api/info/IFuelValueProvider.java b/src/main/java/ic2/api/info/IFuelValueProvider.java new file mode 100644 index 000000000..c4ae62687 --- /dev/null +++ b/src/main/java/ic2/api/info/IFuelValueProvider.java @@ -0,0 +1,8 @@ +package ic2.api.info; + +import net.minecraft.item.*; + +public interface IFuelValueProvider +{ + int getFuelValue(ItemStack p0, boolean p1); +} diff --git a/src/main/java/ic2/api/info/IWindTicker.java b/src/main/java/ic2/api/info/IWindTicker.java new file mode 100644 index 000000000..e1d90f1c4 --- /dev/null +++ b/src/main/java/ic2/api/info/IWindTicker.java @@ -0,0 +1,8 @@ +package ic2.api.info; + +import net.minecraft.world.*; + +public interface IWindTicker +{ + int getWindStrenght(World p0); +} diff --git a/src/main/java/ic2/api/info/Info.java b/src/main/java/ic2/api/info/Info.java new file mode 100644 index 000000000..4538449bd --- /dev/null +++ b/src/main/java/ic2/api/info/Info.java @@ -0,0 +1,30 @@ +package ic2.api.info; + +import net.minecraft.util.*; +import net.minecraftforge.fml.common.*; + +public class Info +{ + public static IEnergyValueProvider itemEnergy; + public static IFuelValueProvider itemFuel; + public static Object ic2ModInstance; + public static DamageSource DMG_ELECTRIC; + public static DamageSource DMG_NUKE_EXPLOSION; + public static DamageSource DMG_RADIATION; + private static Boolean ic2Available; + + public static boolean isIc2Available() { + if (Info.ic2Available != null) { + return Info.ic2Available; + } + final boolean loaded = Loader.isModLoaded("IC2"); + if (Loader.instance().hasReachedState(LoaderState.CONSTRUCTING)) { + Info.ic2Available = loaded; + } + return loaded; + } + + static { + Info.ic2Available = null; + } +} diff --git a/src/main/java/ic2/api/info/package-info.java b/src/main/java/ic2/api/info/package-info.java new file mode 100644 index 000000000..85c10ff14 --- /dev/null +++ b/src/main/java/ic2/api/info/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.info; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/item/ElectricItem.java b/src/main/java/ic2/api/item/ElectricItem.java new file mode 100644 index 000000000..d9237ee61 --- /dev/null +++ b/src/main/java/ic2/api/item/ElectricItem.java @@ -0,0 +1,28 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import java.util.*; + +public final class ElectricItem +{ + public static IElectricItemManager manager; + public static IElectricItemManager rawManager; + private static final List backupManagers; + + public static void registerBackupManager(final IBackupElectricItemManager manager) { + ElectricItem.backupManagers.add(manager); + } + + public static IBackupElectricItemManager getBackupManager(final ItemStack stack) { + for (final IBackupElectricItemManager manager : ElectricItem.backupManagers) { + if (manager.handles(stack)) { + return manager; + } + } + return null; + } + + static { + backupManagers = new ArrayList(); + } +} diff --git a/src/main/java/ic2/api/item/IBackupElectricItemManager.java b/src/main/java/ic2/api/item/IBackupElectricItemManager.java new file mode 100644 index 000000000..93f70f769 --- /dev/null +++ b/src/main/java/ic2/api/item/IBackupElectricItemManager.java @@ -0,0 +1,8 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public interface IBackupElectricItemManager extends IElectricItemManager +{ + boolean handles(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IBlockCuttingBlade.java b/src/main/java/ic2/api/item/IBlockCuttingBlade.java new file mode 100644 index 000000000..8609b9c80 --- /dev/null +++ b/src/main/java/ic2/api/item/IBlockCuttingBlade.java @@ -0,0 +1,6 @@ +package ic2.api.item; + +public interface IBlockCuttingBlade +{ + int gethardness(); +} diff --git a/src/main/java/ic2/api/item/IBoxable.java b/src/main/java/ic2/api/item/IBoxable.java new file mode 100644 index 000000000..c84f9cbb7 --- /dev/null +++ b/src/main/java/ic2/api/item/IBoxable.java @@ -0,0 +1,8 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public interface IBoxable +{ + boolean canBeStoredInToolbox(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IC2Items.java b/src/main/java/ic2/api/item/IC2Items.java new file mode 100644 index 000000000..a4f46c5f9 --- /dev/null +++ b/src/main/java/ic2/api/item/IC2Items.java @@ -0,0 +1,34 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public final class IC2Items +{ + private static Class Ic2Items; + + public static ItemStack getItem(final String name) { + try { + if (IC2Items.Ic2Items == null) { + IC2Items.Ic2Items = Class.forName(getPackage() + ".core.Ic2Items"); + } + final Object ret = IC2Items.Ic2Items.getField(name).get(null); + if (ret instanceof ItemStack) { + return (ItemStack)ret; + } + return null; + } + catch (Exception e) { + System.out.println("IC2 API: Call getItem failed for " + name); + return null; + } + } + + private static String getPackage() { + final Package pkg = IC2Items.class.getPackage(); + if (pkg != null) { + final String packageName = pkg.getName(); + return packageName.substring(0, packageName.length() - ".api.item".length()); + } + return "ic2"; + } +} diff --git a/src/main/java/ic2/api/item/ICustomDamageItem.java b/src/main/java/ic2/api/item/ICustomDamageItem.java new file mode 100644 index 000000000..b0d9d055a --- /dev/null +++ b/src/main/java/ic2/api/item/ICustomDamageItem.java @@ -0,0 +1,15 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import net.minecraft.entity.*; + +public interface ICustomDamageItem +{ + int getCustomDamage(ItemStack p0); + + int getMaxCustomDamage(ItemStack p0); + + void setCustomDamage(ItemStack p0, int p1); + + boolean applyCustomDamage(ItemStack p0, int p1, EntityLivingBase p2); +} diff --git a/src/main/java/ic2/api/item/IDebuggable.java b/src/main/java/ic2/api/item/IDebuggable.java new file mode 100644 index 000000000..499918af6 --- /dev/null +++ b/src/main/java/ic2/api/item/IDebuggable.java @@ -0,0 +1,8 @@ +package ic2.api.item; + +public interface IDebuggable +{ + boolean isDebuggable(); + + String getDebugText(); +} diff --git a/src/main/java/ic2/api/item/IElectricItem.java b/src/main/java/ic2/api/item/IElectricItem.java new file mode 100644 index 000000000..0869f576d --- /dev/null +++ b/src/main/java/ic2/api/item/IElectricItem.java @@ -0,0 +1,18 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public interface IElectricItem +{ + boolean canProvideEnergy(ItemStack p0); + + Item getChargedItem(ItemStack p0); + + Item getEmptyItem(ItemStack p0); + + double getMaxCharge(ItemStack p0); + + int getTier(ItemStack p0); + + double getTransferLimit(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IElectricItemManager.java b/src/main/java/ic2/api/item/IElectricItemManager.java new file mode 100644 index 000000000..3fa3a317f --- /dev/null +++ b/src/main/java/ic2/api/item/IElectricItemManager.java @@ -0,0 +1,21 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import net.minecraft.entity.*; + +public interface IElectricItemManager +{ + double charge(ItemStack p0, double p1, int p2, boolean p3, boolean p4); + + double discharge(ItemStack p0, double p1, int p2, boolean p3, boolean p4, boolean p5); + + double getCharge(ItemStack p0); + + boolean canUse(ItemStack p0, double p1); + + boolean use(ItemStack p0, double p1, EntityLivingBase p2); + + void chargeFromArmor(ItemStack p0, EntityLivingBase p1); + + String getToolTip(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IItemHudInfo.java b/src/main/java/ic2/api/item/IItemHudInfo.java new file mode 100644 index 000000000..65b0aae67 --- /dev/null +++ b/src/main/java/ic2/api/item/IItemHudInfo.java @@ -0,0 +1,9 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import java.util.*; + +public interface IItemHudInfo +{ + List getHudInfo(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IJetpack.java b/src/main/java/ic2/api/item/IJetpack.java new file mode 100644 index 000000000..b7617842b --- /dev/null +++ b/src/main/java/ic2/api/item/IJetpack.java @@ -0,0 +1,12 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public interface IJetpack +{ + void dissableJetpack(ItemStack p0); + + boolean isJetpackActive(ItemStack p0); + + void onLeavingEnergyShield(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IKineticWindRotor.java b/src/main/java/ic2/api/item/IKineticWindRotor.java new file mode 100644 index 000000000..06eea0664 --- /dev/null +++ b/src/main/java/ic2/api/item/IKineticWindRotor.java @@ -0,0 +1,17 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import net.minecraft.util.*; + +public interface IKineticWindRotor +{ + int getDiameter(ItemStack p0); + + ResourceLocation getRotorRenderTexture(ItemStack p0); + + float getEfficiency(ItemStack p0); + + int getMinWindStrength(ItemStack p0); + + int getMaxWindStrength(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/ILatheItem.java b/src/main/java/ic2/api/item/ILatheItem.java new file mode 100644 index 000000000..d1d04bd3a --- /dev/null +++ b/src/main/java/ic2/api/item/ILatheItem.java @@ -0,0 +1,21 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import net.minecraft.util.*; +import net.minecraftforge.fml.relauncher.*; + +public interface ILatheItem +{ + int getWidth(ItemStack p0); + + int[] getCurrentState(ItemStack p0); + + void setState(ItemStack p0, int p1, int p2); + + ItemStack getOutputItem(ItemStack p0, int p1); + + float getOutputChance(ItemStack p0, int p1); + + @SideOnly(Side.CLIENT) + ResourceLocation getTexture(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IMachineUpgradeItem.java b/src/main/java/ic2/api/item/IMachineUpgradeItem.java new file mode 100644 index 000000000..923f63482 --- /dev/null +++ b/src/main/java/ic2/api/item/IMachineUpgradeItem.java @@ -0,0 +1,34 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import ic2.api.tile.*; +import java.util.*; + +public interface IMachineUpgradeItem +{ + int getExtraProcessTime(ItemStack p0, IMachine p1); + + double getProcessTimeMultiplier(ItemStack p0, IMachine p1); + + int getExtraEnergyDemand(ItemStack p0, IMachine p1); + + double getEnergyDemandMultiplier(ItemStack p0, IMachine p1); + + int getExtraEnergyStorage(ItemStack p0, IMachine p1); + + double getEnergyStorageMultiplier(ItemStack p0, IMachine p1); + + int getExtraTier(ItemStack p0, IMachine p1); + + boolean onTick(ItemStack p0, IMachine p1); + + void onProcessEnd(ItemStack p0, IMachine p1, List p2); + + boolean useRedstoneinverter(ItemStack p0, IMachine p1); + + void onInstalling(ItemStack p0, IMachine p1); + + float getSoundVolumeMultiplier(ItemStack p0, IMachine p1); + + IMachine.UpgradeType getType(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/IMetalArmor.java b/src/main/java/ic2/api/item/IMetalArmor.java new file mode 100644 index 000000000..d8f2299b9 --- /dev/null +++ b/src/main/java/ic2/api/item/IMetalArmor.java @@ -0,0 +1,9 @@ +package ic2.api.item; + +import net.minecraft.item.*; +import net.minecraft.entity.player.*; + +public interface IMetalArmor +{ + boolean isMetalArmor(ItemStack p0, EntityPlayer p1); +} diff --git a/src/main/java/ic2/api/item/IScannerItem.java b/src/main/java/ic2/api/item/IScannerItem.java new file mode 100644 index 000000000..f5f59f204 --- /dev/null +++ b/src/main/java/ic2/api/item/IScannerItem.java @@ -0,0 +1,17 @@ +package ic2.api.item; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; +import net.minecraft.util.BlockPos; +import net.minecraft.world.World; + +public interface IScannerItem extends IElectricItem +{ + int startLayerScan(ItemStack p0); + + boolean isValuableOre(ItemStack p0, IBlockState state); + + int getOreValue(ItemStack p0, IBlockState state); + + int getOreValueOfArea(ItemStack p0, World p1, BlockPos pos); +} diff --git a/src/main/java/ic2/api/item/ISpecialElectricItem.java b/src/main/java/ic2/api/item/ISpecialElectricItem.java new file mode 100644 index 000000000..21076c3fd --- /dev/null +++ b/src/main/java/ic2/api/item/ISpecialElectricItem.java @@ -0,0 +1,8 @@ +package ic2.api.item; + +import net.minecraft.item.*; + +public interface ISpecialElectricItem extends IElectricItem +{ + IElectricItemManager getManager(ItemStack p0); +} diff --git a/src/main/java/ic2/api/item/ITerraformingBP.java b/src/main/java/ic2/api/item/ITerraformingBP.java new file mode 100644 index 000000000..ef0b613a9 --- /dev/null +++ b/src/main/java/ic2/api/item/ITerraformingBP.java @@ -0,0 +1,13 @@ +package ic2.api.item; + +import net.minecraft.util.BlockPos; +import net.minecraft.world.*; + +public interface ITerraformingBP +{ + int getConsume(); + + int getRange(); + + boolean terraform(World p0, BlockPos pos); +} diff --git a/src/main/java/ic2/api/item/ItemWrapper.java b/src/main/java/ic2/api/item/ItemWrapper.java new file mode 100644 index 000000000..b862827b2 --- /dev/null +++ b/src/main/java/ic2/api/item/ItemWrapper.java @@ -0,0 +1,46 @@ +package ic2.api.item; + +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Multimap; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class ItemWrapper +{ + private static final Multimap boxableItems; + private static final Multimap metalArmorItems; + + public static void registerBoxable(final Item item, final IBoxable boxable) { + ItemWrapper.boxableItems.put(item, boxable); + } + + public static boolean canBeStoredInToolbox(final ItemStack stack) { + final Item item = stack.getItem(); + for (final IBoxable boxable : ItemWrapper.boxableItems.get(item)) { + if (boxable.canBeStoredInToolbox(stack)) { + return true; + } + } + return item instanceof IBoxable && ((IBoxable)item).canBeStoredInToolbox(stack); + } + + public static void registerMetalArmor(final Item item, final IMetalArmor armor) { + ItemWrapper.metalArmorItems.put(item, armor); + } + + public static boolean isMetalArmor(final ItemStack stack, final EntityPlayer player) { + final Item item = stack.getItem(); + for (final IMetalArmor metalArmor : ItemWrapper.metalArmorItems.get(item)) { + if (metalArmor.isMetalArmor(stack, player)) { + return true; + } + } + return item instanceof IMetalArmor && ((IMetalArmor)item).isMetalArmor(stack, player); + } + + static { + boxableItems = ArrayListMultimap.create(); + metalArmorItems = ArrayListMultimap.create(); + } +} diff --git a/src/main/java/ic2/api/item/package-info.java b/src/main/java/ic2/api/item/package-info.java new file mode 100644 index 000000000..ae84f5449 --- /dev/null +++ b/src/main/java/ic2/api/item/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.item; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/network/INetworkClientTileEntityEventListener.java b/src/main/java/ic2/api/network/INetworkClientTileEntityEventListener.java new file mode 100644 index 000000000..e6d207423 --- /dev/null +++ b/src/main/java/ic2/api/network/INetworkClientTileEntityEventListener.java @@ -0,0 +1,8 @@ +package ic2.api.network; + +import net.minecraft.entity.player.*; + +public interface INetworkClientTileEntityEventListener +{ + void onNetworkEvent(EntityPlayer p0, int p1); +} diff --git a/src/main/java/ic2/api/network/INetworkDataProvider.java b/src/main/java/ic2/api/network/INetworkDataProvider.java new file mode 100644 index 000000000..9557e0249 --- /dev/null +++ b/src/main/java/ic2/api/network/INetworkDataProvider.java @@ -0,0 +1,26 @@ +package ic2.api.network; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; + +import java.util.Collection; +import java.util.Map; + +public interface INetworkDataProvider +{ + /** + * Returns the fields this object has + */ + ImmutableList getNetworkedFields(); + + /** + * Request the specified fields from this object + * @param fields + */ + ImmutableMap getFieldsForSync(Collection fields); + + /** + * Update all fields present in the map + */ + void updateFields(Map fields); +} diff --git a/src/main/java/ic2/api/network/INetworkItemEventListener.java b/src/main/java/ic2/api/network/INetworkItemEventListener.java new file mode 100644 index 000000000..f03a71e80 --- /dev/null +++ b/src/main/java/ic2/api/network/INetworkItemEventListener.java @@ -0,0 +1,9 @@ +package ic2.api.network; + +import net.minecraft.item.*; +import net.minecraft.entity.player.*; + +public interface INetworkItemEventListener +{ + void onNetworkEvent(ItemStack p0, EntityPlayer p1, int p2); +} diff --git a/src/main/java/ic2/api/network/INetworkTileEntityEventListener.java b/src/main/java/ic2/api/network/INetworkTileEntityEventListener.java new file mode 100644 index 000000000..12289d913 --- /dev/null +++ b/src/main/java/ic2/api/network/INetworkTileEntityEventListener.java @@ -0,0 +1,6 @@ +package ic2.api.network; + +public interface INetworkTileEntityEventListener +{ + void onNetworkEvent(int p0); +} diff --git a/src/main/java/ic2/api/network/INetworkUpdateListener.java b/src/main/java/ic2/api/network/INetworkUpdateListener.java new file mode 100644 index 000000000..076ff4a2f --- /dev/null +++ b/src/main/java/ic2/api/network/INetworkUpdateListener.java @@ -0,0 +1,6 @@ +package ic2.api.network; + +public interface INetworkUpdateListener +{ + void onNetworkUpdate(String p0); +} diff --git a/src/main/java/ic2/api/network/NetworkHelper.java b/src/main/java/ic2/api/network/NetworkHelper.java new file mode 100644 index 000000000..a64e2b603 --- /dev/null +++ b/src/main/java/ic2/api/network/NetworkHelper.java @@ -0,0 +1,109 @@ +package ic2.api.network; + +import java.lang.reflect.*; +import net.minecraft.tileentity.*; +import net.minecraft.entity.player.*; +import net.minecraft.item.*; + +public final class NetworkHelper +{ + private static Object instance; + private static Method NetworkManager_updateTileEntityField; + private static Method NetworkManager_initiateTileEntityEvent; + private static Method NetworkManager_initiateItemEvent; + private static Method NetworkManager_initiateClientTileEntityEvent; + private static Method NetworkManager_initiateClientItemEvent; + + public static void updateTileEntityField(final TileEntity te, final String field) { + try { + if (NetworkHelper.NetworkManager_updateTileEntityField == null) { + NetworkHelper.NetworkManager_updateTileEntityField = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("updateTileEntityField", TileEntity.class, String.class); + } + if (NetworkHelper.instance == null) { + NetworkHelper.instance = getInstance(); + } + NetworkHelper.NetworkManager_updateTileEntityField.invoke(NetworkHelper.instance, te, field); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static void initiateTileEntityEvent(final TileEntity te, final int event, final boolean limitRange) { + try { + if (NetworkHelper.NetworkManager_initiateTileEntityEvent == null) { + NetworkHelper.NetworkManager_initiateTileEntityEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateTileEntityEvent", TileEntity.class, Integer.TYPE, Boolean.TYPE); + } + if (NetworkHelper.instance == null) { + NetworkHelper.instance = getInstance(); + } + NetworkHelper.NetworkManager_initiateTileEntityEvent.invoke(NetworkHelper.instance, te, event, limitRange); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static void initiateItemEvent(final EntityPlayer player, final ItemStack itemStack, final int event, final boolean limitRange) { + try { + if (NetworkHelper.NetworkManager_initiateItemEvent == null) { + NetworkHelper.NetworkManager_initiateItemEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateItemEvent", EntityPlayer.class, ItemStack.class, Integer.TYPE, Boolean.TYPE); + } + if (NetworkHelper.instance == null) { + NetworkHelper.instance = getInstance(); + } + NetworkHelper.NetworkManager_initiateItemEvent.invoke(NetworkHelper.instance, player, itemStack, event, limitRange); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static void initiateClientTileEntityEvent(final TileEntity te, final int event) { + try { + if (NetworkHelper.NetworkManager_initiateClientTileEntityEvent == null) { + NetworkHelper.NetworkManager_initiateClientTileEntityEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateClientTileEntityEvent", TileEntity.class, Integer.TYPE); + } + if (NetworkHelper.instance == null) { + NetworkHelper.instance = getInstance(); + } + NetworkHelper.NetworkManager_initiateClientTileEntityEvent.invoke(NetworkHelper.instance, te, event); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + public static void initiateClientItemEvent(final ItemStack itemStack, final int event) { + try { + if (NetworkHelper.NetworkManager_initiateClientItemEvent == null) { + NetworkHelper.NetworkManager_initiateClientItemEvent = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("initiateClientItemEvent", ItemStack.class, Integer.TYPE); + } + if (NetworkHelper.instance == null) { + NetworkHelper.instance = getInstance(); + } + NetworkHelper.NetworkManager_initiateClientItemEvent.invoke(NetworkHelper.instance, itemStack, event); + } + catch (Exception e) { + throw new RuntimeException(e); + } + } + + private static String getPackage() { + final Package pkg = NetworkHelper.class.getPackage(); + if (pkg != null) { + final String packageName = pkg.getName(); + return packageName.substring(0, packageName.length() - ".api.network".length()); + } + return "ic2"; + } + + private static Object getInstance() { + try { + return Class.forName(getPackage() + ".core.IC2").getDeclaredField("network").get(null); + } + catch (Throwable e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/main/java/ic2/api/network/package-info.java b/src/main/java/ic2/api/network/package-info.java new file mode 100644 index 000000000..ed49da23d --- /dev/null +++ b/src/main/java/ic2/api/network/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.network; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/package-info.java b/src/main/java/ic2/api/package-info.java new file mode 100644 index 000000000..f9935f422 --- /dev/null +++ b/src/main/java/ic2/api/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/reactor/IReactor.java b/src/main/java/ic2/api/reactor/IReactor.java new file mode 100644 index 000000000..19ae26327 --- /dev/null +++ b/src/main/java/ic2/api/reactor/IReactor.java @@ -0,0 +1,48 @@ +package ic2.api.reactor; + +import net.minecraft.util.*; +import net.minecraft.world.*; +import net.minecraft.item.*; + +public interface IReactor +{ + BlockPos getPosition(); + + World getWorld(); + + int getHeat(); + + void setHeat(int p0); + + int addHeat(int p0); + + int getMaxHeat(); + + void setMaxHeat(int p0); + + void addEmitHeat(int p0); + + float getHeatEffectModifier(); + + void setHeatEffectModifier(float p0); + + float getReactorEnergyOutput(); + + double getReactorEUEnergyOutput(); + + float addOutput(float p0); + + ItemStack getItemAt(int p0, int p1); + + void setItemAt(int p0, int p1, ItemStack p2); + + void explode(); + + int getTickRate(); + + boolean produceEnergy(); + + void setRedstoneSignal(boolean p0); + + boolean isFluidCooled(); +} diff --git a/src/main/java/ic2/api/reactor/IReactorChamber.java b/src/main/java/ic2/api/reactor/IReactorChamber.java new file mode 100644 index 000000000..af4cf67ea --- /dev/null +++ b/src/main/java/ic2/api/reactor/IReactorChamber.java @@ -0,0 +1,8 @@ +package ic2.api.reactor; + +public interface IReactorChamber +{ + IReactor getReactor(); + + void setRedstoneSignal(boolean p0); +} diff --git a/src/main/java/ic2/api/reactor/IReactorComponent.java b/src/main/java/ic2/api/reactor/IReactorComponent.java new file mode 100644 index 000000000..e8611c581 --- /dev/null +++ b/src/main/java/ic2/api/reactor/IReactorComponent.java @@ -0,0 +1,20 @@ +package ic2.api.reactor; + +import net.minecraft.item.*; + +public interface IReactorComponent +{ + void processChamber(IReactor p0, ItemStack p1, int p2, int p3, boolean p4); + + boolean acceptUraniumPulse(IReactor p0, ItemStack p1, ItemStack p2, int p3, int p4, int p5, int p6, boolean p7); + + boolean canStoreHeat(IReactor p0, ItemStack p1, int p2, int p3); + + int getMaxHeat(IReactor p0, ItemStack p1, int p2, int p3); + + int getCurrentHeat(IReactor p0, ItemStack p1, int p2, int p3); + + int alterHeat(IReactor p0, ItemStack p1, int p2, int p3, int p4); + + float influenceExplosion(IReactor p0, ItemStack p1); +} diff --git a/src/main/java/ic2/api/reactor/ISteamReactor.java b/src/main/java/ic2/api/reactor/ISteamReactor.java new file mode 100644 index 000000000..7045b6e1f --- /dev/null +++ b/src/main/java/ic2/api/reactor/ISteamReactor.java @@ -0,0 +1,10 @@ +package ic2.api.reactor; + +import net.minecraftforge.fluids.*; + +public interface ISteamReactor extends IReactor +{ + FluidTank getWaterTank(); + + FluidTank getSteamTank(); +} diff --git a/src/main/java/ic2/api/reactor/ISteamReactorChamber.java b/src/main/java/ic2/api/reactor/ISteamReactorChamber.java new file mode 100644 index 000000000..9c864d4c6 --- /dev/null +++ b/src/main/java/ic2/api/reactor/ISteamReactorChamber.java @@ -0,0 +1,6 @@ +package ic2.api.reactor; + +public interface ISteamReactorChamber extends IReactorChamber +{ + ISteamReactor getReactor(); +} diff --git a/src/main/java/ic2/api/reactor/ISteamReactorComponent.java b/src/main/java/ic2/api/reactor/ISteamReactorComponent.java new file mode 100644 index 000000000..12e58decd --- /dev/null +++ b/src/main/java/ic2/api/reactor/ISteamReactorComponent.java @@ -0,0 +1,8 @@ +package ic2.api.reactor; + +import net.minecraft.item.*; + +public interface ISteamReactorComponent extends IReactorComponent +{ + void processTick(ISteamReactor p0, ItemStack p1, int p2, int p3, boolean p4, boolean p5); +} diff --git a/src/main/java/ic2/api/reactor/package-info.java b/src/main/java/ic2/api/reactor/package-info.java new file mode 100644 index 000000000..4ca1fd81d --- /dev/null +++ b/src/main/java/ic2/api/reactor/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.reactor; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/recipe/ICannerBottleRecipeManager.java b/src/main/java/ic2/api/recipe/ICannerBottleRecipeManager.java new file mode 100644 index 000000000..645576acc --- /dev/null +++ b/src/main/java/ic2/api/recipe/ICannerBottleRecipeManager.java @@ -0,0 +1,28 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public interface ICannerBottleRecipeManager +{ + void addRecipe(IRecipeInput p0, IRecipeInput p1, ItemStack p2); + + RecipeOutput getOutputFor(ItemStack p0, ItemStack p1, boolean p2, boolean p3); + + Map getRecipes(); + + class Input + { + public final IRecipeInput container; + public final IRecipeInput fill; + + public Input(IRecipeInput container1, IRecipeInput fill1) { + this.container = container1; + this.fill = fill1; + } + + public boolean matches(ItemStack container1, ItemStack fill1) { + return this.container.matches(container1) && this.fill.matches(fill1); + } + } +} diff --git a/src/main/java/ic2/api/recipe/ICannerEnrichRecipeManager.java b/src/main/java/ic2/api/recipe/ICannerEnrichRecipeManager.java new file mode 100644 index 000000000..c4b6e0077 --- /dev/null +++ b/src/main/java/ic2/api/recipe/ICannerEnrichRecipeManager.java @@ -0,0 +1,29 @@ +package ic2.api.recipe; + +import net.minecraftforge.fluids.*; +import net.minecraft.item.*; +import java.util.*; + +public interface ICannerEnrichRecipeManager +{ + void addRecipe(FluidStack p0, IRecipeInput p1, FluidStack p2); + + RecipeOutput getOutputFor(FluidStack p0, ItemStack p1, boolean p2, boolean p3); + + Map getRecipes(); + + class Input + { + public final FluidStack fluid; + public final IRecipeInput additive; + + public Input(FluidStack fluid1, IRecipeInput additive1) { + this.fluid = fluid1; + this.additive = additive1; + } + + public boolean matches(FluidStack fluid1, ItemStack additive1) { + return (this.fluid == null || this.fluid.isFluidEqual(fluid1)) && this.additive.matches(additive1); + } + } +} diff --git a/src/main/java/ic2/api/recipe/ICraftingRecipeManager.java b/src/main/java/ic2/api/recipe/ICraftingRecipeManager.java new file mode 100644 index 000000000..40711ae11 --- /dev/null +++ b/src/main/java/ic2/api/recipe/ICraftingRecipeManager.java @@ -0,0 +1,10 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; + +public interface ICraftingRecipeManager +{ + void addRecipe(ItemStack p0, Object... p1); + + void addShapelessRecipe(ItemStack p0, Object... p1); +} diff --git a/src/main/java/ic2/api/recipe/IFluidHeatManager.java b/src/main/java/ic2/api/recipe/IFluidHeatManager.java new file mode 100644 index 000000000..b38067356 --- /dev/null +++ b/src/main/java/ic2/api/recipe/IFluidHeatManager.java @@ -0,0 +1,24 @@ +package ic2.api.recipe; + +import net.minecraftforge.fluids.*; +import java.util.*; + +public interface IFluidHeatManager extends ILiquidAcceptManager +{ + void addFluid(String p0, int p1, int p2); + + BurnProperty getBurnProperty(Fluid p0); + + Map getBurnProperties(); + + class BurnProperty + { + public final int amount; + public final int heat; + + public BurnProperty(int amount1, int heat1) { + this.amount = amount1; + this.heat = heat1; + } + } +} diff --git a/src/main/java/ic2/api/recipe/ILiquidAcceptManager.java b/src/main/java/ic2/api/recipe/ILiquidAcceptManager.java new file mode 100644 index 000000000..7a46b2b3c --- /dev/null +++ b/src/main/java/ic2/api/recipe/ILiquidAcceptManager.java @@ -0,0 +1,11 @@ +package ic2.api.recipe; + +import net.minecraftforge.fluids.*; +import java.util.*; + +public interface ILiquidAcceptManager +{ + boolean acceptsFluid(Fluid p0); + + Set getAcceptedFluids(); +} diff --git a/src/main/java/ic2/api/recipe/IListRecipeManager.java b/src/main/java/ic2/api/recipe/IListRecipeManager.java new file mode 100644 index 000000000..cea5e2644 --- /dev/null +++ b/src/main/java/ic2/api/recipe/IListRecipeManager.java @@ -0,0 +1,15 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public interface IListRecipeManager extends Iterable +{ + void add(IRecipeInput p0); + + boolean contains(ItemStack p0); + + boolean isEmpty(); + + List getInputs(); +} diff --git a/src/main/java/ic2/api/recipe/IMachineRecipeManager.java b/src/main/java/ic2/api/recipe/IMachineRecipeManager.java new file mode 100644 index 000000000..930c43c13 --- /dev/null +++ b/src/main/java/ic2/api/recipe/IMachineRecipeManager.java @@ -0,0 +1,14 @@ +package ic2.api.recipe; + +import net.minecraft.nbt.*; +import net.minecraft.item.*; +import java.util.*; + +public interface IMachineRecipeManager +{ + void addRecipe(IRecipeInput p0, NBTTagCompound p1, ItemStack... p2); + + RecipeOutput getOutputFor(ItemStack p0, boolean p1); + + Map getRecipes(); +} diff --git a/src/main/java/ic2/api/recipe/IMachineRecipeManagerExt.java b/src/main/java/ic2/api/recipe/IMachineRecipeManagerExt.java new file mode 100644 index 000000000..e43a9b49d --- /dev/null +++ b/src/main/java/ic2/api/recipe/IMachineRecipeManagerExt.java @@ -0,0 +1,9 @@ +package ic2.api.recipe; + +import net.minecraft.nbt.*; +import net.minecraft.item.*; + +public interface IMachineRecipeManagerExt extends IMachineRecipeManager +{ + boolean addRecipe(IRecipeInput p0, NBTTagCompound p1, boolean p2, ItemStack... p3); +} diff --git a/src/main/java/ic2/api/recipe/IPatternStorage.java b/src/main/java/ic2/api/recipe/IPatternStorage.java new file mode 100644 index 000000000..001cfe108 --- /dev/null +++ b/src/main/java/ic2/api/recipe/IPatternStorage.java @@ -0,0 +1,11 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public interface IPatternStorage +{ + boolean addPattern(ItemStack p0); + + List getPatterns(); +} diff --git a/src/main/java/ic2/api/recipe/IRecipeInput.java b/src/main/java/ic2/api/recipe/IRecipeInput.java new file mode 100644 index 000000000..3546cae4c --- /dev/null +++ b/src/main/java/ic2/api/recipe/IRecipeInput.java @@ -0,0 +1,13 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public interface IRecipeInput +{ + boolean matches(ItemStack p0); + + int getAmount(); + + List getInputs(); +} diff --git a/src/main/java/ic2/api/recipe/IScrapboxManager.java b/src/main/java/ic2/api/recipe/IScrapboxManager.java new file mode 100644 index 000000000..ac7451e01 --- /dev/null +++ b/src/main/java/ic2/api/recipe/IScrapboxManager.java @@ -0,0 +1,13 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public interface IScrapboxManager +{ + void addDrop(ItemStack p0, float p1); + + ItemStack getDrop(ItemStack p0, boolean p1); + + Map getDrops(); +} diff --git a/src/main/java/ic2/api/recipe/ISemiFluidFuelManager.java b/src/main/java/ic2/api/recipe/ISemiFluidFuelManager.java new file mode 100644 index 000000000..f25c09233 --- /dev/null +++ b/src/main/java/ic2/api/recipe/ISemiFluidFuelManager.java @@ -0,0 +1,24 @@ +package ic2.api.recipe; + +import net.minecraftforge.fluids.*; +import java.util.*; + +public interface ISemiFluidFuelManager extends ILiquidAcceptManager +{ + void addFluid(String p0, int p1, double p2); + + BurnProperty getBurnProperty(Fluid p0); + + Map getBurnProperties(); + + class BurnProperty + { + public final int amount; + public final double power; + + public BurnProperty(int amount1, double power1) { + this.amount = amount1; + this.power = power1; + } + } +} diff --git a/src/main/java/ic2/api/recipe/RecipeInputFluidContainer.java b/src/main/java/ic2/api/recipe/RecipeInputFluidContainer.java new file mode 100644 index 000000000..cbee55792 --- /dev/null +++ b/src/main/java/ic2/api/recipe/RecipeInputFluidContainer.java @@ -0,0 +1,47 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import net.minecraftforge.fluids.*; +import java.util.*; + +public class RecipeInputFluidContainer implements IRecipeInput +{ + public final Fluid fluid; + public final int amount; + + public RecipeInputFluidContainer(final Fluid fluid) { + this(fluid, 1000); + } + + public RecipeInputFluidContainer(final Fluid fluid, final int amount) { + this.fluid = fluid; + this.amount = amount; + } + + @Override + public boolean matches(final ItemStack subject) { + final FluidStack fs = FluidContainerRegistry.getFluidForFilledItem(subject); + return fs != null && fs.getFluid() == this.fluid; + } + + @Override + public int getAmount() { + return this.amount; + } + + @Override + public List getInputs() { + final List ret = new ArrayList(); + for (final FluidContainerRegistry.FluidContainerData data : FluidContainerRegistry.getRegisteredFluidContainerData()) { + if (data.fluid.getFluid() == this.fluid) { + ret.add(data.filledContainer); + } + } + return ret; + } + + @Override + public String toString() { + return "RInputFluidContainer<" + this.amount + "x" + this.fluid.getName() + ">"; + } +} diff --git a/src/main/java/ic2/api/recipe/RecipeInputItemStack.java b/src/main/java/ic2/api/recipe/RecipeInputItemStack.java new file mode 100644 index 000000000..26ef9b2d4 --- /dev/null +++ b/src/main/java/ic2/api/recipe/RecipeInputItemStack.java @@ -0,0 +1,44 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; + +public class RecipeInputItemStack implements IRecipeInput +{ + public final ItemStack input; + public final int amount; + + public RecipeInputItemStack(final ItemStack aInput) { + this(aInput, aInput.stackSize); + } + + public RecipeInputItemStack(final ItemStack aInput, final int aAmount) { + if (aInput.getItem() == null) { + throw new IllegalArgumentException("Invalid item stack specfied"); + } + this.input = aInput.copy(); + this.amount = aAmount; + } + + @Override + public boolean matches(final ItemStack subject) { + return subject.getItem() == this.input.getItem() && (subject.getItemDamage() == this.input.getItemDamage() || this.input.getItemDamage() == 32767); + } + + @Override + public int getAmount() { + return this.amount; + } + + @Override + public List getInputs() { + return Arrays.asList(this.input); + } + + @Override + public String toString() { + final ItemStack stack = this.input.copy(); + this.input.stackSize = this.amount; + return "RInputItemStack<" + stack + ">"; + } +} diff --git a/src/main/java/ic2/api/recipe/RecipeInputOreDict.java b/src/main/java/ic2/api/recipe/RecipeInputOreDict.java new file mode 100644 index 000000000..88a618dcd --- /dev/null +++ b/src/main/java/ic2/api/recipe/RecipeInputOreDict.java @@ -0,0 +1,92 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import java.util.*; +import net.minecraftforge.oredict.*; + +public class RecipeInputOreDict implements IRecipeInput +{ + public final String input; + public final int amount; + public final Integer meta; + private List ores; + + public RecipeInputOreDict(final String input1) { + this(input1, 1); + } + + public RecipeInputOreDict(final String input1, final int amount1) { + this(input1, amount1, null); + } + + public RecipeInputOreDict(final String input1, final int amount1, final Integer meta) { + this.input = input1; + this.amount = amount1; + this.meta = meta; + } + + @Override + public boolean matches(final ItemStack subject) { + final List inputs = this.getOres(); + final boolean useOreStackMeta = this.meta == null; + final Item subjectItem = subject.getItem(); + final int subjectMeta = subject.getItemDamage(); + for (final ItemStack oreStack : inputs) { + final Item oreItem = oreStack.getItem(); + if (oreItem == null) { + continue; + } + final int metaRequired = useOreStackMeta ? oreStack.getItemDamage() : this.meta; + if (subjectItem == oreItem && (subjectMeta == metaRequired || metaRequired == 32767)) { + return true; + } + } + return false; + } + + @Override + public int getAmount() { + return this.amount; + } + + @Override + public List getInputs() { + final List ores = this.getOres(); + boolean hasInvalidEntries = false; + for (final ItemStack stack : ores) { + if (stack.getItem() == null) { + hasInvalidEntries = true; + break; + } + } + if (!hasInvalidEntries) { + return ores; + } + final List ret = new ArrayList(ores.size()); + for (final ItemStack stack2 : ores) { + if (stack2.getItem() != null) { + ret.add(stack2); + } + } + return Collections.unmodifiableList((List)ret); + } + + @Override + public String toString() { + if (this.meta == null) { + return "RInputOreDict<" + this.amount + "x" + this.input + ">"; + } + return "RInputOreDict<" + this.amount + "x" + this.input + "@" + this.meta + ">"; + } + + private List getOres() { + if (this.ores != null) { + return this.ores; + } + final List ret = (List)OreDictionary.getOres(this.input); + if (ret != OreDictionary.EMPTY_LIST) { + this.ores = ret; + } + return ret; + } +} diff --git a/src/main/java/ic2/api/recipe/RecipeOutput.java b/src/main/java/ic2/api/recipe/RecipeOutput.java new file mode 100644 index 000000000..f670573f5 --- /dev/null +++ b/src/main/java/ic2/api/recipe/RecipeOutput.java @@ -0,0 +1,46 @@ +package ic2.api.recipe; + +import net.minecraft.item.*; +import net.minecraft.nbt.*; +import java.util.*; + +public final class RecipeOutput +{ + public final List items; + public final NBTTagCompound metadata; + + public RecipeOutput(final NBTTagCompound metadata1, final List items1) { + assert !items1.contains(null); + this.metadata = metadata1; + this.items = items1; + } + + public RecipeOutput(final NBTTagCompound metadata1, final ItemStack... items1) { + this(metadata1, Arrays.asList(items1)); + } + + @Override + public boolean equals(final Object obj) { + if (obj instanceof RecipeOutput) { + final RecipeOutput ro = (RecipeOutput)obj; + if (this.items.size() == ro.items.size() && ((this.metadata == null && ro.metadata == null) || (this.metadata != null && ro.metadata != null)) && this.metadata.equals((Object)ro.metadata)) { + final Iterator itA = this.items.iterator(); + final Iterator itB = ro.items.iterator(); + while (itA.hasNext() && itB.hasNext()) { + final ItemStack stackA = itA.next(); + final ItemStack stackB = itB.next(); + if (ItemStack.areItemStacksEqual(stackA, stackB)) { + return false; + } + } + return true; + } + } + return false; + } + + @Override + public String toString() { + return "ROutput<" + this.items + "," + this.metadata + ">"; + } +} diff --git a/src/main/java/ic2/api/recipe/Recipes.java b/src/main/java/ic2/api/recipe/Recipes.java new file mode 100644 index 000000000..4f7676f66 --- /dev/null +++ b/src/main/java/ic2/api/recipe/Recipes.java @@ -0,0 +1,25 @@ +package ic2.api.recipe; + +public class Recipes +{ + public static IMachineRecipeManager macerator; + public static IMachineRecipeManager extractor; + public static IMachineRecipeManager compressor; + public static IMachineRecipeManager centrifuge; + public static IMachineRecipeManager blockcutter; + public static IMachineRecipeManager blastfurance; + public static IMachineRecipeManager recycler; + public static IMachineRecipeManager metalformerExtruding; + public static IMachineRecipeManager metalformerCutting; + public static IMachineRecipeManager metalformerRolling; + public static IMachineRecipeManager oreWashing; + public static ICannerBottleRecipeManager cannerBottle; + public static ICannerEnrichRecipeManager cannerEnrich; + public static IMachineRecipeManager matterAmplifier; + public static IScrapboxManager scrapboxDrops; + public static IListRecipeManager recyclerBlacklist; + public static IListRecipeManager recyclerWhitelist; + public static ICraftingRecipeManager advRecipes; + public static ISemiFluidFuelManager semiFluidGenerator; + public static IFluidHeatManager FluidHeatGenerator; +} diff --git a/src/main/java/ic2/api/recipe/package-info.java b/src/main/java/ic2/api/recipe/package-info.java new file mode 100644 index 000000000..f077c6d29 --- /dev/null +++ b/src/main/java/ic2/api/recipe/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.recipe; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/tile/ExplosionWhitelist.java b/src/main/java/ic2/api/tile/ExplosionWhitelist.java new file mode 100644 index 000000000..e3587133d --- /dev/null +++ b/src/main/java/ic2/api/tile/ExplosionWhitelist.java @@ -0,0 +1,25 @@ +package ic2.api.tile; + +import net.minecraft.block.*; +import java.util.*; + +public final class ExplosionWhitelist +{ + private static Set whitelist; + + public static void addWhitelistedBlock(final Block block) { + ExplosionWhitelist.whitelist.add(block); + } + + public static void removeWhitelistedBlock(final Block block) { + ExplosionWhitelist.whitelist.remove(block); + } + + public static boolean isBlockWhitelisted(final Block block) { + return ExplosionWhitelist.whitelist.contains(block); + } + + static { + ExplosionWhitelist.whitelist = new HashSet<>(); + } +} diff --git a/src/main/java/ic2/api/tile/IEnergyStorage.java b/src/main/java/ic2/api/tile/IEnergyStorage.java new file mode 100644 index 000000000..2a711036d --- /dev/null +++ b/src/main/java/ic2/api/tile/IEnergyStorage.java @@ -0,0 +1,20 @@ +package ic2.api.tile; + +import net.minecraft.util.EnumFacing; + +public interface IEnergyStorage +{ + int getStored(); + + void setStored(int p0); + + int addEnergy(int p0); + + int getCapacity(); + + int getOutput(); + + double getOutputEnergyUnitsPerTick(); + + boolean isTeleporterCompatible(EnumFacing p0); +} diff --git a/src/main/java/ic2/api/tile/IMachine.java b/src/main/java/ic2/api/tile/IMachine.java new file mode 100644 index 000000000..9a34c52f7 --- /dev/null +++ b/src/main/java/ic2/api/tile/IMachine.java @@ -0,0 +1,33 @@ +package ic2.api.tile; + +import net.minecraft.item.*; +import java.util.*; + +public interface IMachine +{ + double getEnergy(); + + boolean useEnergy(double p0, boolean p1); + + void setRedstoneSensitive(boolean p0); + + boolean isRedstoneSensitive(); + + boolean getActive(); + + boolean isValidInput(ItemStack p0); + + List getSupportedTypes(); + + enum UpgradeType + { + ImportExport, + MachineModifierA, + MachineModifierB, + RedstoneControl, + Processing, + Sounds, + WorldInteraction, + Custom; + } +} diff --git a/src/main/java/ic2/api/tile/IWrenchable.java b/src/main/java/ic2/api/tile/IWrenchable.java index 8fcbea59e..c58237102 100644 --- a/src/main/java/ic2/api/tile/IWrenchable.java +++ b/src/main/java/ic2/api/tile/IWrenchable.java @@ -1,61 +1,20 @@ package ic2.api.tile; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.item.ItemStack; +import net.minecraft.entity.player.*; +import net.minecraft.item.*; +import net.minecraft.util.EnumFacing; -/** - * Allows a tile entity to make use of the wrench's removal and rotation functions. - */ -public interface IWrenchable { - /** - * Determine if the wrench can be used to set the block's facing. - * Called before wrenchCanRemove(). - * - * @param entityPlayer player using the wrench, may be null - * @param side block's side the wrench was clicked on - * @return Whether the wrenching was done and the wrench should be damaged - */ - boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side); - - /** - * Get the block's facing. - * - * @return Block facing - */ - short getFacing(); - - /** - * Set the block's facing - * - * @param facing facing to set the block to - */ - void setFacing(short facing); - - /** - * Determine if the wrench can be used to remove the block. - * Called if wrenchSetFacing fails. - * - * @param entityPlayer player using the wrench, may be null - * @return Whether the wrenching was done and the wrench should be damaged - */ - boolean wrenchCanRemove(EntityPlayer entityPlayer); - - /** - * Determine the probability to drop the block as it is. - * The first entry in getDrops will be replaced by blockid:meta if the drop is successful. - * - * @return Probability from 0 to 1 - */ - float getWrenchDropRate(); - - /** - * Determine the item the block will drop when the wrenching is successful. - * - * The ItemStack will be copied before creating the EntityItem. - * - * @param entityPlayer player using the wrench, may be null - * @return ItemStack to drop, may be null - */ - ItemStack getWrenchDrop(EntityPlayer entityPlayer); +public interface IWrenchable +{ + boolean wrenchCanSetFacing(EntityPlayer p0, EnumFacing p1); + + EnumFacing getFacing(); + + void setFacing(EnumFacing facing); + + boolean wrenchCanRemove(EntityPlayer p0); + + float getWrenchDropRate(); + + ItemStack getWrenchDrop(EntityPlayer p0); } - diff --git a/src/main/java/ic2/api/tile/package-info.java b/src/main/java/ic2/api/tile/package-info.java new file mode 100644 index 000000000..509e3c2c1 --- /dev/null +++ b/src/main/java/ic2/api/tile/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.tile; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/ic2/api/util/IKeyboard.java b/src/main/java/ic2/api/util/IKeyboard.java new file mode 100644 index 000000000..aa15a4b30 --- /dev/null +++ b/src/main/java/ic2/api/util/IKeyboard.java @@ -0,0 +1,22 @@ +package ic2.api.util; + +import net.minecraft.entity.player.*; + +public interface IKeyboard +{ + boolean isAltKeyDown(EntityPlayer p0); + + boolean isBoostKeyDown(EntityPlayer p0); + + boolean isForwardKeyDown(EntityPlayer p0); + + boolean isJumpKeyDown(EntityPlayer p0); + + boolean isModeSwitchKeyDown(EntityPlayer p0); + + boolean isSideinventoryKeyDown(EntityPlayer p0); + + boolean isHudModeKeyDown(EntityPlayer p0); + + boolean isSneakKeyDown(EntityPlayer p0); +} diff --git a/src/main/java/ic2/api/util/Keys.java b/src/main/java/ic2/api/util/Keys.java new file mode 100644 index 000000000..65c6d5ce0 --- /dev/null +++ b/src/main/java/ic2/api/util/Keys.java @@ -0,0 +1,6 @@ +package ic2.api.util; + +public class Keys +{ + public static IKeyboard instance; +} diff --git a/src/main/java/ic2/api/util/package-info.java b/src/main/java/ic2/api/util/package-info.java new file mode 100644 index 000000000..c6c25beed --- /dev/null +++ b/src/main/java/ic2/api/util/package-info.java @@ -0,0 +1,5 @@ +@API(apiVersion = "1.0", owner = "IC2", provides = "IC2API") +package ic2.api.util; + +import net.minecraftforge.fml.common.*; + diff --git a/src/main/java/techreborn/client/gui/GuiBlastFurnace.java b/src/main/java/techreborn/client/gui/GuiBlastFurnace.java index d521406f7..d881e6d37 100644 --- a/src/main/java/techreborn/client/gui/GuiBlastFurnace.java +++ b/src/main/java/techreborn/client/gui/GuiBlastFurnace.java @@ -43,7 +43,7 @@ public class GuiBlastFurnace extends GuiContainer { GuiButton button = new GuiButton(212, k + 4, l + 6, 20, 20, ""); buttonList.add(button); super.initGui(); - CoordTriplet coordinates = new CoordTriplet(blastfurnace.getPos().getX() - (EnumFacing.getFront(blastfurnace.getFacing()).getFrontOffsetX() * 2), blastfurnace.getPos().getY() - 1, blastfurnace.getPos().getZ() - (EnumFacing.getFront(blastfurnace.getFacing()).getFrontOffsetZ() * 2)); + CoordTriplet coordinates = new CoordTriplet(blastfurnace.getPos().getX() - (EnumFacing.getFront(blastfurnace.getFacingInt()).getFrontOffsetX() * 2), blastfurnace.getPos().getY() - 1, blastfurnace.getPos().getZ() - (EnumFacing.getFront(blastfurnace.getFacingInt()).getFrontOffsetZ() * 2)); if(coordinates.equals(ClientProxy.multiblockRenderEvent.anchor) && blastfurnace.getHeat() != 0){ ClientProxy.multiblockRenderEvent.setMultiblock(null); button.displayString = "B"; @@ -136,7 +136,7 @@ public class GuiBlastFurnace extends GuiContainer { MultiblockSet set = new MultiblockSet(multiblock); ClientProxy.multiblockRenderEvent.setMultiblock(set); ClientProxy.multiblockRenderEvent.partent = new Location(blastfurnace.getPos().getX(), blastfurnace.getPos().getY(), blastfurnace.getPos().getZ(), blastfurnace.getWorld()); - ClientProxy.multiblockRenderEvent.anchor = new CoordTriplet(blastfurnace.getPos().getX() - (EnumFacing.getFront(blastfurnace.getFacing()).getFrontOffsetX() * 2), blastfurnace.getPos().getY() - 1, blastfurnace.getPos().getZ() - (EnumFacing.getFront(blastfurnace.getFacing()).getFrontOffsetZ() * 2)); + ClientProxy.multiblockRenderEvent.anchor = new CoordTriplet(blastfurnace.getPos().getX() - (EnumFacing.getFront(blastfurnace.getFacingInt()).getFrontOffsetX() * 2), blastfurnace.getPos().getY() - 1, blastfurnace.getPos().getZ() - (EnumFacing.getFront(blastfurnace.getFacingInt()).getFrontOffsetZ() * 2)); } button.displayString = "A"; } else { diff --git a/src/main/java/techreborn/powerSystem/TilePowerAcceptor.java b/src/main/java/techreborn/powerSystem/TilePowerAcceptor.java index 4c2e45bea..570e6ed0e 100644 --- a/src/main/java/techreborn/powerSystem/TilePowerAcceptor.java +++ b/src/main/java/techreborn/powerSystem/TilePowerAcceptor.java @@ -3,8 +3,16 @@ package techreborn.powerSystem; import cofh.api.energy.IEnergyProvider; import cofh.api.energy.IEnergyReceiver; import com.mojang.realmsclient.gui.ChatFormatting; +import ic2.api.energy.event.EnergyTileUnloadEvent; +import ic2.api.energy.tile.IEnergySink; +import ic2.api.energy.tile.IEnergySource; +import ic2.api.energy.tile.IEnergySourceInfo; +import ic2.api.energy.tile.IEnergyTile; +import ic2.api.info.Info; import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; +import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fml.common.Optional; import reborncore.api.IListInfoProvider; import techreborn.api.power.IEnergyInterfaceTile; @@ -20,9 +28,9 @@ import java.util.List; }) public abstract class TilePowerAcceptor extends RFProviderTile implements IEnergyReceiver, IEnergyProvider, //Cofh - IEnergyInterfaceTile, IListInfoProvider //TechReborn - //IEnergyTile, IEnergySink, IEnergySource, //Ic2 - // IEnergySourceInfo //IC2 Classic //TODO ic2 + IEnergyInterfaceTile, IListInfoProvider, //TechReborn + IEnergyTile, IEnergySink, IEnergySource, //Ic2 + IEnergySourceInfo //IC2 Classic //TODO ic2 { public int tier; private double energy; @@ -57,67 +65,67 @@ public abstract class TilePowerAcceptor extends RFProviderTile implements onChunkUnload(); } -// @Override -// public void onChunkUnload() { -// super.onChunkUnload(); -// if (PowerSystem.EUPOWENET) { -// if (addedToEnet && -// Info.isIc2Available()) { -// MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); -// -// addedToEnet = false; -// } -// } -// } -// -// @Override -// public double getDemandedEnergy() { -// if (!PowerSystem.EUPOWENET) -// return 0; -// return Math.min(getMaxPower() - getEnergy(), getMaxInput()); -// } -// -// @Override -// public int getSinkTier() { -// return tier; -// } -// -// @Override -// public double injectEnergy(EnumFacing directionFrom, double amount, double voltage) { -// setEnergy(getEnergy() + amount); -// return 0; -// } -// -// @Override -// public boolean acceptsEnergyFrom(TileEntity emitter, EnumFacing direction) { -// if (!PowerSystem.EUPOWENET) -// return false; -// return canAcceptEnergy(direction); -// } -// -// @Override -// public boolean emitsEnergyTo(TileEntity receiver, EnumFacing direction) { -// if (!PowerSystem.EUPOWENET) -// return false; -// return canProvideEnergy(direction); -// } -// -// @Override -// public double getOfferedEnergy() { -// if (!PowerSystem.EUPOWENET) -// return 0; -// return Math.min(getEnergy(), getMaxOutput()); -// } -// -// @Override -// public void drawEnergy(double amount) { -// useEnergy((int) amount); -// } -// -// @Override -// public int getSourceTier() { -// return tier; -// } + @Override + public void onChunkUnload() { + super.onChunkUnload(); + if (PowerSystem.EUPOWENET) { + if (addedToEnet && + Info.isIc2Available()) { + MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this)); + + addedToEnet = false; + } + } + } + + @Override + public double getDemandedEnergy() { + if (!PowerSystem.EUPOWENET) + return 0; + return Math.min(getMaxPower() - getEnergy(), getMaxInput()); + } + + @Override + public int getSinkTier() { + return tier; + } + + @Override + public double injectEnergy(EnumFacing directionFrom, double amount, double voltage) { + setEnergy(getEnergy() + amount); + return 0; + } + + @Override + public boolean acceptsEnergyFrom(TileEntity emitter, EnumFacing direction) { + if (!PowerSystem.EUPOWENET) + return false; + return canAcceptEnergy(direction); + } + + @Override + public boolean emitsEnergyTo(TileEntity receiver, EnumFacing direction) { + if (!PowerSystem.EUPOWENET) + return false; + return canProvideEnergy(direction); + } + + @Override + public double getOfferedEnergy() { + if (!PowerSystem.EUPOWENET) + return 0; + return Math.min(getEnergy(), getMaxOutput()); + } + + @Override + public void drawEnergy(double amount) { + useEnergy((int) amount); + } + + @Override + public int getSourceTier() { + return tier; + } //END IC2 //COFH @@ -289,12 +297,12 @@ public abstract class TilePowerAcceptor extends RFProviderTile implements } //IC2 Classic -// -// -// @Override -// public int getMaxEnergyAmount() { -// return (int) getMaxOutput(); -// } + + + @Override + public int getMaxEnergyAmount() { + return (int) getMaxOutput(); + } public void charge(int slot) diff --git a/src/main/java/techreborn/powerSystem/traits/EUItemPowerTrait.java b/src/main/java/techreborn/powerSystem/traits/EUItemPowerTrait.java index ded6c0775..88676fd76 100644 --- a/src/main/java/techreborn/powerSystem/traits/EUItemPowerTrait.java +++ b/src/main/java/techreborn/powerSystem/traits/EUItemPowerTrait.java @@ -1,39 +1,42 @@ package techreborn.powerSystem.traits; +import ic2.api.item.IElectricItem; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; import reborncore.jtraits.JTrait; import techreborn.api.power.IEnergyInterfaceItem; -//TODO ic2 -public class EUItemPowerTrait extends JTrait {//implements IElectricItem { -// @Override -// public boolean canProvideEnergy(ItemStack itemStack) { -// return _self.canAcceptEnergy(itemStack); -// } -// -// @Override -// public Item getChargedItem(ItemStack itemStack) { -// return (Item) _self; -// } -// -// @Override -// public Item getEmptyItem(ItemStack itemStack) { -// return (Item) _self; -// } -// -// @Override -// public double getMaxCharge(ItemStack itemStack) { -// return _self.getMaxPower(itemStack); -// } -// -// @Override -// public int getTier(ItemStack itemStack) { -// return _self.getStackTeir(itemStack); -// } -// -// @Override -// public double getTransferLimit(ItemStack itemStack) { -// return _self.getMaxTransfer(itemStack); -// } +public class EUItemPowerTrait extends JTrait implements IElectricItem { + + @Override + public boolean canProvideEnergy(ItemStack itemStack) { + return _self.canAcceptEnergy(itemStack); + } + + @Override + public Item getChargedItem(ItemStack itemStack) { + return (Item) _self; + } + + @Override + public Item getEmptyItem(ItemStack itemStack) { + return (Item) _self; + } + + @Override + public double getMaxCharge(ItemStack itemStack) { + return _self.getMaxPower(itemStack); + } + + @Override + public int getTier(ItemStack itemStack) { + return _self.getStackTeir(itemStack); + } + + @Override + public double getTransferLimit(ItemStack itemStack) { + return _self.getMaxTransfer(itemStack); + } } diff --git a/src/main/java/techreborn/tiles/TileAesu.java b/src/main/java/techreborn/tiles/TileAesu.java index 726a4f657..dd77f4d0d 100644 --- a/src/main/java/techreborn/tiles/TileAesu.java +++ b/src/main/java/techreborn/tiles/TileAesu.java @@ -44,23 +44,14 @@ public class TileAesu extends TilePowerAcceptor implements IWrenchable { } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { - if (!entityPlayer.isSneaking()) { - return true; - } + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return (short) getFacingInt(); + public EnumFacing getFacing() { + return getFacingEnum(); } - - @Override - public void setFacing(short facing) { - setFacing(facing); - } - @Override public boolean wrenchCanRemove(EntityPlayer entityPlayer) { if (entityPlayer.isSneaking()) { @@ -144,12 +135,12 @@ public class TileAesu extends TilePowerAcceptor implements IWrenchable { @Override public boolean canAcceptEnergy(EnumFacing direction) { - return getFacing() != Functions.getIntDirFromDirection(direction); + return getFacingEnum() != direction; } @Override public boolean canProvideEnergy(EnumFacing direction) { - return getFacing() == Functions.getIntDirFromDirection(direction); + return getFacingEnum() == direction; } @Override diff --git a/src/main/java/techreborn/tiles/TileAlloyFurnace.java b/src/main/java/techreborn/tiles/TileAlloyFurnace.java index a850bae12..da5c200bf 100644 --- a/src/main/java/techreborn/tiles/TileAlloyFurnace.java +++ b/src/main/java/techreborn/tiles/TileAlloyFurnace.java @@ -9,6 +9,7 @@ import net.minecraft.init.Items; import net.minecraft.inventory.IInventory; import net.minecraft.item.*; import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; import net.minecraft.util.IChatComponent; import net.minecraftforge.fml.common.registry.GameRegistry; import reborncore.common.util.Inventory; @@ -224,17 +225,13 @@ public class TileAlloyFurnace extends TileMachineBase implements IWrenchable, II } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileAlloySmelter.java b/src/main/java/techreborn/tiles/TileAlloySmelter.java index 512d41045..8eecb1f93 100644 --- a/src/main/java/techreborn/tiles/TileAlloySmelter.java +++ b/src/main/java/techreborn/tiles/TileAlloySmelter.java @@ -45,17 +45,13 @@ public class TileAlloySmelter extends TilePowerAcceptor implements IWrenchable, @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileAssemblingMachine.java b/src/main/java/techreborn/tiles/TileAssemblingMachine.java index da0873b2f..875281e58 100644 --- a/src/main/java/techreborn/tiles/TileAssemblingMachine.java +++ b/src/main/java/techreborn/tiles/TileAssemblingMachine.java @@ -39,17 +39,13 @@ public class TileAssemblingMachine extends TilePowerAcceptor implements IWrencha } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileBlastFurnace.java b/src/main/java/techreborn/tiles/TileBlastFurnace.java index 603cb762d..dc6512029 100644 --- a/src/main/java/techreborn/tiles/TileBlastFurnace.java +++ b/src/main/java/techreborn/tiles/TileBlastFurnace.java @@ -54,21 +54,13 @@ public class TileBlastFurnace extends TilePowerAcceptor implements IWrenchable, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - Block block = worldObj.getBlockState(pos).getBlock(); - if(block instanceof BlockMachineBase){ - return (short) ((BlockMachineBase) block).getFacing(worldObj.getBlockState(pos)).getIndex(); - } - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileCentrifuge.java b/src/main/java/techreborn/tiles/TileCentrifuge.java index e9e079bf7..9d5e8644e 100644 --- a/src/main/java/techreborn/tiles/TileCentrifuge.java +++ b/src/main/java/techreborn/tiles/TileCentrifuge.java @@ -50,17 +50,13 @@ public class TileCentrifuge extends TilePowerAcceptor implements IWrenchable, II @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileChargeBench.java b/src/main/java/techreborn/tiles/TileChargeBench.java index 060b7fd32..34ab21572 100644 --- a/src/main/java/techreborn/tiles/TileChargeBench.java +++ b/src/main/java/techreborn/tiles/TileChargeBench.java @@ -43,17 +43,13 @@ public class TileChargeBench extends TilePowerAcceptor implements IWrenchable, I @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileChemicalReactor.java b/src/main/java/techreborn/tiles/TileChemicalReactor.java index e5b4db54d..3050dcbcf 100644 --- a/src/main/java/techreborn/tiles/TileChemicalReactor.java +++ b/src/main/java/techreborn/tiles/TileChemicalReactor.java @@ -39,17 +39,13 @@ public class TileChemicalReactor extends TilePowerAcceptor implements IWrenchabl } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileChunkLoader.java b/src/main/java/techreborn/tiles/TileChunkLoader.java index dbc7e917d..81b1a054d 100644 --- a/src/main/java/techreborn/tiles/TileChunkLoader.java +++ b/src/main/java/techreborn/tiles/TileChunkLoader.java @@ -24,17 +24,13 @@ public class TileChunkLoader extends TilePowerAcceptor implements IWrenchable, I } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileDieselGenerator.java b/src/main/java/techreborn/tiles/TileDieselGenerator.java index db1b460bb..82f71101c 100644 --- a/src/main/java/techreborn/tiles/TileDieselGenerator.java +++ b/src/main/java/techreborn/tiles/TileDieselGenerator.java @@ -32,17 +32,13 @@ public class TileDieselGenerator extends TilePowerAcceptor implements IWrenchabl } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileDigitalChest.java b/src/main/java/techreborn/tiles/TileDigitalChest.java index ae90cdde6..afe949078 100644 --- a/src/main/java/techreborn/tiles/TileDigitalChest.java +++ b/src/main/java/techreborn/tiles/TileDigitalChest.java @@ -8,6 +8,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.NetworkManager; import net.minecraft.network.Packet; import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.util.EnumFacing; import net.minecraft.util.IChatComponent; import reborncore.api.IListInfoProvider; import reborncore.common.util.Inventory; @@ -187,17 +188,13 @@ public class TileDigitalChest extends TileMachineBase implements IInventory, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileDragonEggSiphoner.java b/src/main/java/techreborn/tiles/TileDragonEggSiphoner.java index 18c9038aa..3cc1af3d6 100644 --- a/src/main/java/techreborn/tiles/TileDragonEggSiphoner.java +++ b/src/main/java/techreborn/tiles/TileDragonEggSiphoner.java @@ -35,17 +35,13 @@ public class TileDragonEggSiphoner extends TilePowerAcceptor implements IWrencha } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileGasTurbine.java b/src/main/java/techreborn/tiles/TileGasTurbine.java index c8973d974..b3563750f 100644 --- a/src/main/java/techreborn/tiles/TileGasTurbine.java +++ b/src/main/java/techreborn/tiles/TileGasTurbine.java @@ -45,17 +45,13 @@ public class TileGasTurbine extends TilePowerAcceptor implements IWrenchable, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileGrinder.java b/src/main/java/techreborn/tiles/TileGrinder.java index e34af1627..c77836685 100644 --- a/src/main/java/techreborn/tiles/TileGrinder.java +++ b/src/main/java/techreborn/tiles/TileGrinder.java @@ -48,17 +48,13 @@ public class TileGrinder extends TilePowerAcceptor implements IWrenchable, IFlui } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileHeatGenerator.java b/src/main/java/techreborn/tiles/TileHeatGenerator.java index 2e0eedbd4..d1cb0a38b 100644 --- a/src/main/java/techreborn/tiles/TileHeatGenerator.java +++ b/src/main/java/techreborn/tiles/TileHeatGenerator.java @@ -39,17 +39,13 @@ public class TileHeatGenerator extends TilePowerAcceptor implements IWrenchable } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileImplosionCompressor.java b/src/main/java/techreborn/tiles/TileImplosionCompressor.java index bc52f7198..d32deafac 100644 --- a/src/main/java/techreborn/tiles/TileImplosionCompressor.java +++ b/src/main/java/techreborn/tiles/TileImplosionCompressor.java @@ -37,17 +37,13 @@ public class TileImplosionCompressor extends TilePowerAcceptor implements IWrenc } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java b/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java index d1ccd7556..b6fdf8777 100644 --- a/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java +++ b/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java @@ -42,17 +42,13 @@ public class TileIndustrialElectrolyzer extends TilePowerAcceptor implements IWr } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileIndustrialSawmill.java b/src/main/java/techreborn/tiles/TileIndustrialSawmill.java index ed5b8a002..0c4f2ac59 100644 --- a/src/main/java/techreborn/tiles/TileIndustrialSawmill.java +++ b/src/main/java/techreborn/tiles/TileIndustrialSawmill.java @@ -77,17 +77,13 @@ public class TileIndustrialSawmill extends TilePowerAcceptor implements IWrencha @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileMatterFabricator.java b/src/main/java/techreborn/tiles/TileMatterFabricator.java index cae77c838..9d90d336c 100644 --- a/src/main/java/techreborn/tiles/TileMatterFabricator.java +++ b/src/main/java/techreborn/tiles/TileMatterFabricator.java @@ -29,17 +29,13 @@ public class TileMatterFabricator extends TilePowerAcceptor implements IWrenchab } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileQuantumChest.java b/src/main/java/techreborn/tiles/TileQuantumChest.java index 48096764c..f8e34497c 100644 --- a/src/main/java/techreborn/tiles/TileQuantumChest.java +++ b/src/main/java/techreborn/tiles/TileQuantumChest.java @@ -8,6 +8,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.NetworkManager; import net.minecraft.network.Packet; import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.util.EnumFacing; import net.minecraft.util.IChatComponent; import powercrystals.minefactoryreloaded.api.IDeepStorageUnit; import reborncore.api.IListInfoProvider; @@ -229,17 +230,13 @@ public class TileQuantumChest extends TileMachineBase implements IInventory, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileQuantumTank.java b/src/main/java/techreborn/tiles/TileQuantumTank.java index ed7353ab8..0d1b1f5fe 100644 --- a/src/main/java/techreborn/tiles/TileQuantumTank.java +++ b/src/main/java/techreborn/tiles/TileQuantumTank.java @@ -209,17 +209,13 @@ public class TileQuantumTank extends TileMachineBase implements IFluidHandler, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileRollingMachine.java b/src/main/java/techreborn/tiles/TileRollingMachine.java index 90e5f871e..8b98a38b9 100644 --- a/src/main/java/techreborn/tiles/TileRollingMachine.java +++ b/src/main/java/techreborn/tiles/TileRollingMachine.java @@ -135,17 +135,13 @@ public class TileRollingMachine extends TilePowerAcceptor implements IWrenchable } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileSemifluidGenerator.java b/src/main/java/techreborn/tiles/TileSemifluidGenerator.java index 946c61a3c..ee46b6a8c 100644 --- a/src/main/java/techreborn/tiles/TileSemifluidGenerator.java +++ b/src/main/java/techreborn/tiles/TileSemifluidGenerator.java @@ -51,17 +51,13 @@ public class TileSemifluidGenerator extends TilePowerAcceptor implements IWrench } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileThermalGenerator.java b/src/main/java/techreborn/tiles/TileThermalGenerator.java index 62d25e7df..6dd1a4158 100644 --- a/src/main/java/techreborn/tiles/TileThermalGenerator.java +++ b/src/main/java/techreborn/tiles/TileThermalGenerator.java @@ -33,17 +33,13 @@ public class TileThermalGenerator extends TilePowerAcceptor implements IWrenchab } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override diff --git a/src/main/java/techreborn/tiles/TileVacuumFreezer.java b/src/main/java/techreborn/tiles/TileVacuumFreezer.java index 1cf87a17c..ef14fd44b 100644 --- a/src/main/java/techreborn/tiles/TileVacuumFreezer.java +++ b/src/main/java/techreborn/tiles/TileVacuumFreezer.java @@ -69,17 +69,13 @@ public class TileVacuumFreezer extends TilePowerAcceptor implements IWrenchable, } @Override - public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) { + public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, EnumFacing side) { return false; } @Override - public short getFacing() { - return 0; - } - - @Override - public void setFacing(short facing) { + public EnumFacing getFacing() { + return getFacingEnum(); } @Override