red stone wire block

majesticmadman98 · March 11, 2014

i want to make a block that functions like redstone but can be pushed by pistons so if i connect redstone to either side it would complete the circuit but i dont want it to generate a curretn like the redstone block

PeterRDevries · March 11, 2014

You should copy the normal redstone dust code and use it for a block

majesticmadman98 · March 11, 2014

would that then break when used with a piston

PeterRDevries · March 11, 2014

For the piston you should copy the bedrock code where it can't be pushed by a piston

majesticmadman98 · March 11, 2014

sorry let me clarify i want it to be pushed by a piston, but redstone wire is broken when pushed by a piston

majesticmadman98 · March 11, 2014

also what do i set the texture to if i want it to use a standard minecraft redstone block texture or do i need to copy the texture itself and do it manually

PeterRDevries · March 11, 2014

if you use the redstone wire code for a block and remove the pushed by piston part it should work

majesticmadman98 · March 11, 2014

ok i've got this so what part of this needs replacing to be a block over the wire

package a.sounds;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Random;

import java.util.Set;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

import net.minecraft.block.Block;

import net.minecraft.block.material.Material;

import net.minecraft.client.renderer.texture.IconRegister;

import net.minecraft.creativetab.CreativeTabs;

import net.minecraft.item.Item;

import net.minecraft.util.AxisAlignedBB;

import net.minecraft.util.Direction;

import net.minecraft.util.Icon;

import net.minecraft.world.ChunkPosition;

import net.minecraft.world.IBlockAccess;

import net.minecraft.world.World;

public class RedstoneConducter extends Block

{

public RedstoneConducter(int par1, Material par2Material) {

super(par1, par2Material);

}

/**

* When false, power transmission methods do not look at other redstone wires. Used internally during

* updateCurrentStrength.

*/

private boolean wiresProvidePower = true;

private Set blocksNeedingUpdate = new HashSet();

@SideOnly(Side.CLIENT)

private Icon field_94413_c;

@SideOnly(Side.CLIENT)

private Icon field_94410_cO;

@SideOnly(Side.CLIENT)

private Icon field_94411_cP;

@SideOnly(Side.CLIENT)

private Icon field_94412_cQ;

public RedstoneConducter(int par1)

{

super(par1, Material.circuits);

this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);

}

/**

* Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been

* cleared to be reused)

*/

public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)

{

return null;

}

/**

* Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two

* adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.

*/

public boolean isOpaqueCube()

{

return false;

}

/**

* If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)

*/

public boolean renderAsNormalBlock()

{

return false;

}

/**

* The type of render function that is called for this block

*/

public int getRenderType()

{

return 5;

}

@SideOnly(Side.CLIENT)

/**

* Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called

* when first determining what to render.

*/

public int colorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)

{

return 8388608;

}

/**

* Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z

*/

public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)

{

return par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) || par1World.getBlockId(par2, par3 - 1, par4) == Block.glowStone.blockID;

}

/**

* Sets the strength of the wire current (0-15) for this block based on neighboring blocks and propagates to

* neighboring redstone wires

*/

private void updateAndPropagateCurrentStrength(World par1World, int par2, int par3, int par4)

{

this.calculateCurrentChanges(par1World, par2, par3, par4, par2, par3, par4);

ArrayList arraylist = new ArrayList(this.blocksNeedingUpdate);

this.blocksNeedingUpdate.clear();

for (int l = 0; l < arraylist.size(); ++l)

{

ChunkPosition chunkposition = (ChunkPosition)arraylist.get(l);

par1World.notifyBlocksOfNeighborChange(chunkposition.x, chunkposition.y, chunkposition.z, this.blockID);

}

private void calculateCurrentChanges(World par1World, int par2, int par3, int par4, int par5, int par6, int par7)

{

int k1 = par1World.getBlockMetadata(par2, par3, par4);

byte b0 = 0;

int l1 = this.getMaxCurrentStrength(par1World, par5, par6, par7, b0);

this.wiresProvidePower = false;

int i2 = par1World.getStrongestIndirectPower(par2, par3, par4);

this.wiresProvidePower = true;

if (i2 > 0 && i2 > l1 - 1)

{

l1 = i2;

}

int j2 = 0;

for (int k2 = 0; k2 < 4; ++k2)

{

int l2 = par2;

int i3 = par4;

if (k2 == 0)

{

l2 = par2 - 1;

}

if (k2 == 1)

{

++l2;

}

if (k2 == 2)

{

i3 = par4 - 1;

}

if (k2 == 3)

{

++i3;

}

if (l2 != par5 || i3 != par7)

{

j2 = this.getMaxCurrentStrength(par1World, l2, par3, i3, j2);

}

if (par1World.isBlockNormalCube(l2, par3, i3) && !par1World.isBlockNormalCube(par2, par3 + 1, par4))

{

if ((l2 != par5 || i3 != par7) && par3 >= par6)

{

j2 = this.getMaxCurrentStrength(par1World, l2, par3 + 1, i3, j2);

}

else if (!par1World.isBlockNormalCube(l2, par3, i3) && (l2 != par5 || i3 != par7) && par3 <= par6)

{

j2 = this.getMaxCurrentStrength(par1World, l2, par3 - 1, i3, j2);

}

if (j2 > l1)

{

l1 = j2 - 1;

}

else if (l1 > 0)

{

--l1;

}

else

{

l1 = 0;

}

if (i2 > l1 - 1)

{

l1 = i2;

}

if (k1 != l1)

{

par1World.setBlockMetadataWithNotify(par2, par3, par4, l1, 2);

this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4));

this.blocksNeedingUpdate.add(new ChunkPosition(par2 - 1, par3, par4));

this.blocksNeedingUpdate.add(new ChunkPosition(par2 + 1, par3, par4));

this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3 - 1, par4));

this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3 + 1, par4));

this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4 - 1));

this.blocksNeedingUpdate.add(new ChunkPosition(par2, par3, par4 + 1));

}

/**

* Calls World.notifyBlocksOfNeighborChange() for all neighboring blocks, but only if the given block is a redstone

* wire.

*/

private void notifyWireNeighborsOfNeighborChange(World par1World, int par2, int par3, int par4)

{

if (par1World.getBlockId(par2, par3, par4) == this.blockID)

{

par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);

}

/**

* Called whenever the block is added into the world. Args: world, x, y, z

*/

public void onBlockAdded(World par1World, int par2, int par3, int par4)

{

super.onBlockAdded(par1World, par2, par3, par4);

if (!par1World.isRemote)

{

this.updateAndPropagateCurrentStrength(par1World, par2, par3, par4);

par1World.notifyBlocksOfNeighborChange(par2, par3 + 1, par4, this.blockID);

par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);

this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3, par4);

this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3, par4);

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 - 1);

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3, par4 + 1);

if (par1World.isBlockNormalCube(par2 - 1, par3, par4))

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 + 1, par4);

}

else

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2 - 1, par3 - 1, par4);

}

if (par1World.isBlockNormalCube(par2 + 1, par3, par4))

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 + 1, par4);

}

else

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2 + 1, par3 - 1, par4);

}

if (par1World.isBlockNormalCube(par2, par3, par4 - 1))

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 - 1);

}

else

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 - 1);

}

if (par1World.isBlockNormalCube(par2, par3, par4 + 1))

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 + 1, par4 + 1);

}

else

{

this.notifyWireNeighborsOfNeighborChange(par1World, par2, par3 - 1, par4 + 1);

}

/**

* Called on server worlds only when the block has been replaced by a different block ID, or the same block with a

* different metadata value, but before the new metadata value is set. Args: World, x, y, z, old block ID, old

* metadata

*/

public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)

{

super.breakBlock(par1World, par2, par3, par4, par5, par6);