+ Added some basis for new redstone things.

2 files changed, 400 insertions, 0 deletions

diff --git a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
index bb7004350d..5a0d2cc256 100644
--- a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
+++ b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
@@ -7,6 +7,7 @@ import gtPlusPlus.core.block.general.BlockSuperLight.TileEntitySuperLight;
 import gtPlusPlus.core.block.machine.Machine_SuperJukebox.TileEntitySuperJukebox;
 import gtPlusPlus.core.lib.LoadedMods;
 import gtPlusPlus.core.tileentities.general.*;
+import gtPlusPlus.core.tileentities.general.redstone.TileEntityRedstoneHandler;
 import gtPlusPlus.core.tileentities.machines.*;
 import gtPlusPlus.plugin.villagers.tile.TileEntityGenericSpawner;
 
@@ -31,6 +32,7 @@ public class ModTileEntities {
 		GameRegistry.registerTileEntity(TileEntityDecayablesChest.class, "TileDecayablesChest");		
 		GameRegistry.registerTileEntity(TileEntitySuperJukebox.class, "TileEntitySuperJukebox");
 		GameRegistry.registerTileEntity(TileEntitySuperLight.class, "TileEntitySuperLight");
+		GameRegistry.registerTileEntity(TileEntityRedstoneHandler.class, "TileEntityRedstoneHandler");
 
 		
 		//Mod TEs
diff --git a/src/Java/gtPlusPlus/core/tileentities/general/redstone/TileEntityRedstoneHandler.java b/src/Java/gtPlusPlus/core/tileentities/general/redstone/TileEntityRedstoneHandler.java
new file mode 100644
index 0000000000..fbd5f4280d
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/tileentities/general/redstone/TileEntityRedstoneHandler.java
@@ -0,0 +1,398 @@
+package gtPlusPlus.core.tileentities.general.redstone;
+
+import gtPlusPlus.api.interfaces.IToolable;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.util.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.EnumSkyBlock;
+import net.minecraft.world.IBlockAccess;
+
+public class TileEntityRedstoneHandler extends TileEntity implements IToolable {
+
+	private final int mTileType;
+	private BlockPos mTilePos;
+	private boolean mRequiresUpdate = false;
+	private Long mStartTime;
+	private int mLightValue = 0;
+	
+	/**
+	 * Sets the Redstone Handler Type. 
+	 * @param aTileType - A type of the handler designated by an int. 0 = receiver, 1 = emitter, 2 = both, anything else = nothing.
+	 */
+	public TileEntityRedstoneHandler(int aTileType) {
+		mTileType = aTileType;
+	}
+	
+	public Block getBlock() {
+		return mTilePos != null ? mTilePos.getBlockAtPos() : Blocks.redstone_block;
+	}
+	
+	
+	@Override
+	public void readFromNBT(NBTTagCompound aNBT) {
+		mStartTime = aNBT.getLong("mStartTime");
+		mInvName = aNBT.getString("mInvName");
+		mLightValue = aNBT.getInteger("mLightValue");
+		super.readFromNBT(aNBT);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound aNBT) {
+		aNBT.setInteger("mTileType", mTileType);
+		aNBT.setLong("mStartTime", mStartTime);
+		aNBT.setString("mInvName", mInvName);
+		aNBT.setInteger("mLightValue", mLightValue);
+		super.writeToNBT(aNBT);
+	}
+	
+
+	private boolean mHasUpdatedRecently = false;
+	
+	private final boolean init() {
+		if (mTilePos == null) {
+			try {
+				mTilePos = new BlockPos(this);
+			} catch (Throwable t) {
+				return false;
+			}
+		}
+		if (mStartTime == null) {
+			try {
+				mStartTime = System.currentTimeMillis();
+			} catch (Throwable t) {
+				return false;
+			}
+		}
+		return true;
+	}
+	private Long mLastUpdate;
+	private String mInvName = "";
+	
+	@Override
+	public void updateEntity() {		
+		//Handle init
+		if (!init()) {
+			return;
+		}		
+		if (mRequiresUpdate) {
+			mRequiresUpdate = false;
+			mHasUpdatedRecently = true;
+			mLastUpdate = System.currentTimeMillis();
+			if (mTilePos.world.getBlockLightValue(xCoord, yCoord, zCoord) != mLightValue) {
+				mTilePos.world.setLightValue(EnumSkyBlock.Block, xCoord, yCoord, zCoord, mLightValue);				
+			}			
+			markDirty();
+		}		
+		if (Utils.getMillisSince(mLastUpdate, System.currentTimeMillis()) >= 5000) {
+			if (mHasUpdatedRecently) {
+				mHasUpdatedRecently = false;
+			}
+		}		
+		
+		if (Utils.getMillisSince(mStartTime, System.currentTimeMillis()) % 50 == 0) {
+			
+		}
+		
+		
+		
+		super.updateEntity();
+	}
+	
+	public final void markForUpdate() {
+		mRequiresUpdate = true;
+	}
+	
+	public final boolean hasUpdatedRecently() {
+		return mHasUpdatedRecently;
+	}
+
+	@Override
+	public int getBlockMetadata() {
+		return super.getBlockMetadata();
+	}
+
+	@Override
+	public void markDirty() {
+		super.markDirty();
+	}
+
+	@Override
+	public boolean canUpdate() {
+		return true;
+	}
+	
+	public void setRedstoneState(boolean aRedstoneActive) {
+		
+	}
+	
+	public void setCurrentTextureArray(IIcon[] aTextures) {
+		
+	}
+	
+    /**
+     * Used to see if one of the blocks next to you or your block is getting power from a neighboring block. Used by
+     * items like TNT or Doors so they don't have redstone going straight into them.  Args: x, y, z
+     */
+	public boolean isGettingIndirectlyPowered() {
+		if (mTilePos == null) {
+			return false;
+		}
+		return mTilePos.world.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord);
+	}
+	
+	public int getStrongestIndirectPower() {
+		if (mTilePos == null) {
+			return 0;
+		}
+		return mTilePos.world.getStrongestIndirectPower(xCoord, yCoord, zCoord);		
+	}
+	
+    /**
+     * Gets the power level from a certain block face.  Args: x, y, z, direction
+     */
+	public int getIndirectPowerForSide(int aSide) {
+		if (mTilePos == null || aSide <0 || aSide > 5) {
+			return 0;
+		}
+		return mTilePos.world.getIndirectPowerLevelTo(xCoord, yCoord, zCoord, aSide);		
+	}
+	
+	/**
+     * Returns the highest redstone signal strength powering the given block. Args: X, Y, Z.
+     */
+	public int getBlockPowerInput() {
+		if (mTilePos == null) {
+			return 0;
+		}
+		return mTilePos.world.getBlockPowerInput(xCoord, yCoord, zCoord);		
+	}	
+	
+    /**
+     * Determine if this block can make a redstone connection on the side provided,
+     * Useful to control which sides are inputs and outputs for redstone wires.
+     *
+     * Side:
+     *  -1: UP
+     *   0: NORTH
+     *   1: EAST
+     *   2: SOUTH
+     *   3: WEST
+     *
+     * @param world The current world
+     * @param x X Position
+     * @param y Y Position
+     * @param z Z Position
+     * @param side The side that is trying to make the connection
+     * @return True to make the connection
+     */
+	public boolean canConnectRedstone(IBlockAccess world, int x, int y, int z, int side) {
+		if (mTilePos == null) {
+			return false;
+		}
+		return getBlock().canConnectRedstone(world, xCoord, yCoord, zCoord, side);
+	}
+
+    /**
+     * Called to determine whether to allow the a block to handle its own indirect power rather than using the default rules.
+     * @param world The world
+     * @param x The x position of this block instance
+     * @param y The y position of this block instance
+     * @param z The z position of this block instance
+     * @param side The INPUT side of the block to be powered - ie the opposite of this block's output side
+     * @return Whether Block#isProvidingWeakPower should be called when determining indirect power
+     */
+	public boolean shouldCheckWeakPower(IBlockAccess world, int x, int y, int z, int side) {
+		if (mTilePos == null) {
+			return false;
+		}
+		return getBlock().shouldCheckWeakPower(world, xCoord, yCoord, zCoord, side);
+	}
+
+    /**
+     * If this block should be notified of weak changes.
+     * Weak changes are changes 1 block away through a solid block.
+     * Similar to comparators.
+     *
+     * @param world The current world
+     * @param x X Position
+     * @param y Y position
+     * @param z Z position
+     * @param side The side to check
+     * @return true To be notified of changes
+     */
+	public boolean getWeakChanges(IBlockAccess world, int x, int y, int z) {
+		if (mTilePos == null) {
+			return false;
+		}
+		return getBlock().getWeakChanges(world, xCoord, yCoord, zCoord);
+	}
+	
+	
+	/**
+	 * Override this to change the level of redstone output.
+	 * @return
+	 */
+	public int getRedstoneLevel() {
+		if (mTilePos == null) {
+			return 0;
+		}
+		if (canSupplyRedstoneSignal()) {
+			int aInputPower = getInputPowerLevel();
+			if (aInputPower > 0) {
+				return aInputPower;
+			}
+		}
+		return 0;
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	/*
+	 * Alk's Simplified Redstone Handling functions (Fuck redstone)
+	 */
+	
+	/**
+	 * 
+	 * @return - Does this Block supply redstone signal at all?
+	 */
+	public final boolean isPowered() {
+		return canAcceptRedstoneSignal() && getInputPowerLevel() > 0;
+	}
+	
+	/**
+	 * 
+	 * @return - Can this Block provide redstone signal at all?
+	 */
+	public final boolean isProvidingPower() {
+		return canSupplyRedstoneSignal() && getOutputPowerLevel() > 0;
+	}
+	
+	/**
+	 * 
+	 * @return - (0-15) Redstone Output signal level
+	 */
+	public final int getOutputPowerLevel() {
+		return getRedstoneLevel();
+	}
+	
+	/**
+	 * 
+	 * @return (0-15) Redstone Input Signal level
+	 */
+	public final int getInputPowerLevel() {
+		return getBlockPowerInput();
+	}
+	
+	/**
+	 * 
+	 * @return - Does this Tile Entity support outputting redstone?
+	 */
+	public final boolean canSupplyRedstoneSignal() {
+		return mTileType == 1 || mTileType == 2;
+	}
+	
+	/**
+	 * 
+	 * @return - Does this Tile Entity support inputting redstone?
+	 */
+	public final boolean canAcceptRedstoneSignal() {
+		return mTileType == 0 || mTileType == 2;
+	}
+
+
+	@Override
+	public boolean isScrewdriverable() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onScrewdriverLMB() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onScrewdriverRMB() {
+		return false;
+	}
+
+
+	@Override
+	public boolean isWrenchable() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onWrenchLMB() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onWrenchRMB() {
+		return false;
+	}
+
+
+	@Override
+	public boolean isMalletable() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onMalletLMB() {
+		return false;
+	}
+
+
+	@Override
+	public boolean onMalletRMB() {
+		return false;
+	}
+
+
+	public void setCustomName(String displayName) {
+		this.mInvName = displayName;		
+	}
+	
+	public String getCustomName() {
+		return this.mInvName;
+	}
+
+	public String getInventoryName() {
+		return this.hasCustomInventoryName() ? this.mInvName : "container.redstone.generic";
+	}
+
+	public boolean hasCustomInventoryName() {
+		return (this.mInvName != null) && !this.mInvName.equals("");
+	}
+
+	public int isProvidingWeakPower(IBlockAccess world, int x, int y, int z, int side) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	public int isProvidingStrongPower(IBlockAccess world, int x, int y, int z, int side) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+	
+	
+	
+	
+	
+	
+}