/// <summary>
/// Returns true if the given side of this block type should be rendered, if the adjacent block is at the given
/// coordinates. Args: blockAccess, x, y, z, side
/// </summary>
public override bool ShouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (BlockType)
{
base.ShouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5);
}
if (par5 != 1 && par5 != 0 && !base.ShouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5))
{
return(false);
}
int i = par2;
int j = par3;
int k = par4;
i += Facing.OffsetsXForSide[Facing.FaceToSide[par5]];
j += Facing.OffsetsYForSide[Facing.FaceToSide[par5]];
k += Facing.OffsetsZForSide[Facing.FaceToSide[par5]];
bool flag = (par1IBlockAccess.GetBlockMetadata(i, j, k) & 8) != 0;
if (!flag)
{
if (par5 == 1)
{
return(true);
}
if (par5 == 0 && base.ShouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5))
{
return(true);
}
else
{
return(par1IBlockAccess.GetBlockId(par2, par3, par4) != BlockID || (par1IBlockAccess.GetBlockMetadata(par2, par3, par4) & 8) != 0);
}
}
if (par5 == 0)
{
return(true);
}
if (par5 == 1 && base.ShouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5))
{
return(true);
}
else
{
return(par1IBlockAccess.GetBlockId(par2, par3, par4) != BlockID || (par1IBlockAccess.GetBlockMetadata(par2, par3, par4) & 8) == 0);
}
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4) & 7;
float f = (float)(2 * (1 + i)) / 16F;
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, f, 1.0F);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
switch (GetDirectionMeta(i))
{
case 0:
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.25F, 1.0F);
break;
case 1:
SetBlockBounds(0.0F, 0.75F, 0.0F, 1.0F, 1.0F, 1.0F);
break;
case 2:
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.25F);
break;
case 3:
SetBlockBounds(0.0F, 0.0F, 0.75F, 1.0F, 1.0F, 1.0F);
break;
case 4:
SetBlockBounds(0.0F, 0.0F, 0.0F, 0.25F, 1.0F, 1.0F);
break;
case 5:
SetBlockBounds(0.75F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
break;
}
}
public virtual int Func_35296_f(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (i < 7)
{
return(-1);
}
if (par1IBlockAccess.GetBlockId(par2 - 1, par3, par4) == FruitType.BlockID)
{
return(0);
}
if (par1IBlockAccess.GetBlockId(par2 + 1, par3, par4) == FruitType.BlockID)
{
return(1);
}
if (par1IBlockAccess.GetBlockId(par2, par3, par4 - 1) == FruitType.BlockID)
{
return(2);
}
return(par1IBlockAccess.GetBlockId(par2, par3, par4 + 1) != FruitType.BlockID ? -1 : 3);
}
/// <summary>
/// Retrieves the block texture to use based on the display side. Args: iBlockAccess, x, y, z, side
/// </summary>
public override int GetBlockTexture(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (par5 == 1)
{
return(BlockIndexInTexture + 17);
}
if (par5 == 0)
{
return(BlockIndexInTexture + 17);
}
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (par5 != i)
{
return(BlockIndexInTexture);
}
if (IsActive)
{
return(BlockIndexInTexture + 16);
}
else
{
return(BlockIndexInTexture - 1);
}
}
/// <summary>
/// Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
/// when first determining what to render.
/// </summary>
public override int ColorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if ((i & 3) == 1)
{
return(ColorizerFoliage.GetFoliageColorPine());
}
if ((i & 3) == 2)
{
return(ColorizerFoliage.GetFoliageColorBirch());
}
int j = 0;
int k = 0;
int l = 0;
for (int i1 = -1; i1 <= 1; i1++)
{
for (int j1 = -1; j1 <= 1; j1++)
{
int k1 = par1IBlockAccess.GetBiomeGenForCoords(par2 + j1, par4 + i1).GetBiomeFoliageColor();
j += (k1 & 0xff0000) >> 16;
k += (k1 & 0xff00) >> 8;
l += k1 & 0xff;
}
}
return((j / 9 & 0xff) << 16 | (k / 9 & 0xff) << 8 | l / 9 & 0xff);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
int j = i & 7;
bool flag = (i & 8) > 0;
float f = 0.375F;
float f1 = 0.625F;
float f2 = 0.1875F;
float f3 = 0.125F;
if (flag)
{
f3 = 0.0625F;
}
if (j == 1)
{
SetBlockBounds(0.0F, f, 0.5F - f2, f3, f1, 0.5F + f2);
}
else if (j == 2)
{
SetBlockBounds(1.0F - f3, f, 0.5F - f2, 1.0F, f1, 0.5F + f2);
}
else if (j == 3)
{
SetBlockBounds(0.5F - f2, f, 0.0F, 0.5F + f2, f1, f3);
}
else if (j == 4)
{
SetBlockBounds(0.5F - f2, f, 1.0F - f3, 0.5F + f2, f1, 1.0F);
}
}
/// <summary>
/// Is this block powering the block on the specified side
/// </summary>
public override bool IsPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (!TorchActive)
{
return(false);
}
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (i == 5 && par5 == 1)
{
return(false);
}
if (i == 3 && par5 == 3)
{
return(false);
}
if (i == 4 && par5 == 2)
{
return(false);
}
if (i == 1 && par5 == 5)
{
return(false);
}
return(i != 2 || par5 != 4);
}
/// <summary>
/// Is this block powering the block on the specified side
/// </summary>
public override bool IsPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (!IsRepeaterPowered)
{
return(false);
}
int i = GetDirection(par1IBlockAccess.GetBlockMetadata(par2, par3, par4));
if (i == 0 && par5 == 3)
{
return(true);
}
if (i == 1 && par5 == 4)
{
return(true);
}
if (i == 2 && par5 == 2)
{
return(true);
}
return(i == 3 && par5 == 5);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
MaxY = (float)(par1IBlockAccess.GetBlockMetadata(par2, par3, par4) * 2 + 2) / 16F;
float f = 0.125F;
SetBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, (float)MaxY, 0.5F + f);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4) & 7;
float f = 0.1875F;
if (i == 1)
{
SetBlockBounds(0.0F, 0.2F, 0.5F - f, f * 2.0F, 0.8F, 0.5F + f);
}
else if (i == 2)
{
SetBlockBounds(1.0F - f * 2.0F, 0.2F, 0.5F - f, 1.0F, 0.8F, 0.5F + f);
}
else if (i == 3)
{
SetBlockBounds(0.5F - f, 0.2F, 0.0F, 0.5F + f, 0.8F, f * 2.0F);
}
else if (i == 4)
{
SetBlockBounds(0.5F - f, 0.2F, 1.0F - f * 2.0F, 0.5F + f, 0.8F, 1.0F);
}
else
{
float f1 = 0.25F;
SetBlockBounds(0.5F - f1, 0.0F, 0.5F - f1, 0.5F + f1, 0.6F, 0.5F + f1);
}
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
float f = 0.0625F;
float f1 = (float)(1 + i * 2) / 16F;
float f2 = 0.5F;
SetBlockBounds(f1, 0.0F, f, 1.0F - f, f2, 1.0F - f);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (i >= 2 && i <= 5)
{
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.625F, 1.0F);
}
else
{
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
}
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = GetDirection(par1IBlockAccess.GetBlockMetadata(par2, par3, par4));
if (i == 2 || i == 0)
{
SetBlockBounds(0.0F, 0.0F, 0.375F, 1.0F, 1.0F, 0.625F);
}
else
{
SetBlockBounds(0.375F, 0.0F, 0.0F, 0.625F, 1.0F, 1.0F);
}
}
/// <summary>
/// Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
/// when first determining what to render.
/// </summary>
public override int ColorMultiplier(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (i == 0)
{
return(0xffffff);
}
else
{
return(par1IBlockAccess.GetBiomeGenForCoords(par2, par4).GetBiomeGrassColor());
}
}
/// <summary>
/// Returns the full metadata value created by combining the metadata of both blocks the door takes up.
/// </summary>
public virtual int GetFullMetadata(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
bool flag = (i & 8) != 0;
int j;
int k;
if (flag)
{
j = par1IBlockAccess.GetBlockMetadata(par2, par3 - 1, par4);
k = i;
}
else
{
j = i;
k = par1IBlockAccess.GetBlockMetadata(par2, par3 + 1, par4);
}
bool flag1 = (k & 1) != 0;
int l = j & 7 | (flag ? 8 : 0) | (flag1 ? 0x10 : 0);
return(l);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
bool flag = par1IBlockAccess.GetBlockMetadata(par2, par3, par4) == 1;
float f = 0.0625F;
if (flag)
{
SetBlockBounds(f, 0.0F, f, 1.0F - f, 0.03125F, 1.0F - f);
}
else
{
SetBlockBounds(f, 0.0F, f, 1.0F - f, 0.0625F, 1.0F - f);
}
}
/// <summary>
/// Returns the flow decay but converts values indicating falling liquid (values >=8) to their effective source block
/// value of zero.
/// </summary>
protected virtual int GetEffectiveFlowDecay(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
if (par1IBlockAccess.GetBlockMaterial(par2, par3, par4) != BlockMaterial)
{
return(-1);
}
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (i >= 8)
{
i = 0;
}
return(i);
}
/// <summary>
/// Returns true if the block coordinate passed can provide power, or is a redstone wire, or if its a repeater that
/// is powered.
/// </summary>
public static bool IsPoweredOrRepeater(IBlockAccess par0IBlockAccess, int par1, int par2, int par3, int par4)
{
if (IsPowerProviderOrWire(par0IBlockAccess, par1, par2, par3, par4))
{
return(true);
}
int i = par0IBlockAccess.GetBlockId(par1, par2, par3);
if (i == Block.RedstoneRepeaterActive.BlockID)
{
int j = par0IBlockAccess.GetBlockMetadata(par1, par2, par3);
return(par4 == (j & 3));
}
else
{
return(false);
}
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
if (BlockType)
{
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
else
{
bool flag = (par1IBlockAccess.GetBlockMetadata(par2, par3, par4) & 8) != 0;
if (flag)
{
SetBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
}
else
{
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
}
}
}
/// <summary>
/// Returns true if the block coordinate passed can provide power, or is a redstone wire.
/// </summary>
public static bool IsPowerProviderOrWire(IBlockAccess par0IBlockAccess, int par1, int par2, int par3, int par4)
{
int i = par0IBlockAccess.GetBlockId(par1, par2, par3);
if (i == Block.RedstoneWire.BlockID)
{
return(true);
}
if (i == 0)
{
return(false);
}
if (i == Block.RedstoneRepeaterIdle.BlockID || i == Block.RedstoneRepeaterActive.BlockID)
{
int j = par0IBlockAccess.GetBlockMetadata(par1, par2, par3);
return(par4 == (j & 3) || par4 == Direction.FootInvisibleFaceRemap[j & 3]);
}
return(Block.BlocksList[i].CanProvidePower() && par4 != -1);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
if (IsExtended(i))
{
switch (GetOrientation(i))
{
case 0:
SetBlockBounds(0.0F, 0.25F, 0.0F, 1.0F, 1.0F, 1.0F);
break;
case 1:
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.75F, 1.0F);
break;
case 2:
SetBlockBounds(0.0F, 0.0F, 0.25F, 1.0F, 1.0F, 1.0F);
break;
case 3:
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 0.75F);
break;
case 4:
SetBlockBounds(0.25F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
break;
case 5:
SetBlockBounds(0.0F, 0.0F, 0.0F, 0.75F, 1.0F, 1.0F);
break;
}
}
else
{
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
if (IsFreestanding)
{
return;
}
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
float f = 0.28125F;
float f1 = 0.78125F;
float f2 = 0.0F;
float f3 = 1.0F;
float f4 = 0.125F;
SetBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
if (i == 2)
{
SetBlockBounds(f2, f, 1.0F - f4, f3, f1, 1.0F);
}
if (i == 3)
{
SetBlockBounds(f2, f, 0.0F, f3, f1, f4);
}
if (i == 4)
{
SetBlockBounds(1.0F - f4, f, f2, 1.0F, f1, f3);
}
if (i == 5)
{
SetBlockBounds(0.0F, f, f2, f4, f1, f3);
}
}
public override bool GetBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
return(IsFenceGateOpen(par1IBlockAccess.GetBlockMetadata(par2, par3, par4)));
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int i = par1IBlockAccess.GetBlockMetadata(par2, par3, par4);
float f = 1.0F;
float f1 = 1.0F;
float f2 = 1.0F;
float f3 = 0.0F;
float f4 = 0.0F;
float f5 = 0.0F;
bool flag = i > 0;
if ((i & 2) != 0)
{
f3 = Math.Max(f3, 0.0625F);
f = 0.0F;
f1 = 0.0F;
f4 = 1.0F;
f2 = 0.0F;
f5 = 1.0F;
flag = true;
}
if ((i & 8) != 0)
{
f = Math.Min(f, 0.9375F);
f3 = 1.0F;
f1 = 0.0F;
f4 = 1.0F;
f2 = 0.0F;
f5 = 1.0F;
flag = true;
}
if ((i & 4) != 0)
{
f5 = Math.Max(f5, 0.0625F);
f2 = 0.0F;
f = 0.0F;
f3 = 1.0F;
f1 = 0.0F;
f4 = 1.0F;
flag = true;
}
if ((i & 1) != 0)
{
f2 = Math.Min(f2, 0.9375F);
f5 = 1.0F;
f = 0.0F;
f3 = 1.0F;
f1 = 0.0F;
f4 = 1.0F;
flag = true;
}
if (!flag && CanBePlacedOn(par1IBlockAccess.GetBlockId(par2, par3 + 1, par4)))
{
f1 = Math.Min(f1, 0.9375F);
f4 = 1.0F;
f = 0.0F;
f3 = 1.0F;
f2 = 0.0F;
f5 = 1.0F;
}
SetBlockBounds(f, f1, f2, f3, f4, f5);
}
/// <summary>
/// Updates the blocks bounds based on its current state. Args: world, x, y, z
/// </summary>
public override void SetBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
SetBlockBoundsForBlockRender(par1IBlockAccess.GetBlockMetadata(par2, par3, par4));
}
public override bool GetBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
return(!IsTrapdoorOpen(par1IBlockAccess.GetBlockMetadata(par2, par3, par4)));
}
/// <summary>
/// Is this block powering the block on the specified side
/// </summary>
public override bool IsPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
return(par1IBlockAccess.GetBlockMetadata(par2, par3, par4) > 0);
}
/// <summary>
/// Returns a vector indicating the direction and intensity of fluid flow.
/// </summary>
private Vec3D GetFlowVector(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
Vec3D vec3d = Vec3D.CreateVector(0.0F, 0.0F, 0.0F);
int i = GetEffectiveFlowDecay(par1IBlockAccess, par2, par3, par4);
for (int j = 0; j < 4; j++)
{
int k = par2;
int l = par3;
int i1 = par4;
if (j == 0)
{
k--;
}
if (j == 1)
{
i1--;
}
if (j == 2)
{
k++;
}
if (j == 3)
{
i1++;
}
int j1 = GetEffectiveFlowDecay(par1IBlockAccess, k, l, i1);
if (j1 < 0)
{
if (par1IBlockAccess.GetBlockMaterial(k, l, i1).BlocksMovement())
{
continue;
}
j1 = GetEffectiveFlowDecay(par1IBlockAccess, k, l - 1, i1);
if (j1 >= 0)
{
int k1 = j1 - (i - 8);
vec3d = vec3d.AddVector((k - par2) * k1, (l - par3) * k1, (i1 - par4) * k1);
}
continue;
}
if (j1 >= 0)
{
int l1 = j1 - i;
vec3d = vec3d.AddVector((k - par2) * l1, (l - par3) * l1, (i1 - par4) * l1);
}
}
if (par1IBlockAccess.GetBlockMetadata(par2, par3, par4) >= 8)
{
bool flag = false;
if (flag || IsBlockSolid(par1IBlockAccess, par2, par3, par4 - 1, 2))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2, par3, par4 + 1, 3))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2 - 1, par3, par4, 4))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2 + 1, par3, par4, 5))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2, par3 + 1, par4 - 1, 2))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2, par3 + 1, par4 + 1, 3))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2 - 1, par3 + 1, par4, 4))
{
flag = true;
}
if (flag || IsBlockSolid(par1IBlockAccess, par2 + 1, par3 + 1, par4, 5))
{
flag = true;
}
if (flag)
{
vec3d = vec3d.Normalize().AddVector(0.0F, -6D, 0.0F);
}
}
vec3d = vec3d.Normalize();
return(vec3d);
}
/// <summary>
/// Is this block powering the block on the specified side
/// </summary>
public override bool IsPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
if (!WiresProvidePower)
{
return(false);
}
if (par1IBlockAccess.GetBlockMetadata(par2, par3, par4) == 0)
{
return(false);
}
if (par5 == 1)
{
return(true);
}
bool flag = IsPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3, par4, 1) || !par1IBlockAccess.IsBlockNormalCube(par2 - 1, par3, par4) && IsPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3 - 1, par4, -1);
bool flag1 = IsPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3, par4, 3) || !par1IBlockAccess.IsBlockNormalCube(par2 + 1, par3, par4) && IsPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3 - 1, par4, -1);
bool flag2 = IsPoweredOrRepeater(par1IBlockAccess, par2, par3, par4 - 1, 2) || !par1IBlockAccess.IsBlockNormalCube(par2, par3, par4 - 1) && IsPoweredOrRepeater(par1IBlockAccess, par2, par3 - 1, par4 - 1, -1);
bool flag3 = IsPoweredOrRepeater(par1IBlockAccess, par2, par3, par4 + 1, 0) || !par1IBlockAccess.IsBlockNormalCube(par2, par3, par4 + 1) && IsPoweredOrRepeater(par1IBlockAccess, par2, par3 - 1, par4 + 1, -1);
if (!par1IBlockAccess.IsBlockNormalCube(par2, par3 + 1, par4))
{
if (par1IBlockAccess.IsBlockNormalCube(par2 - 1, par3, par4) && IsPoweredOrRepeater(par1IBlockAccess, par2 - 1, par3 + 1, par4, -1))
{
flag = true;
}
if (par1IBlockAccess.IsBlockNormalCube(par2 + 1, par3, par4) && IsPoweredOrRepeater(par1IBlockAccess, par2 + 1, par3 + 1, par4, -1))
{
flag1 = true;
}
if (par1IBlockAccess.IsBlockNormalCube(par2, par3, par4 - 1) && IsPoweredOrRepeater(par1IBlockAccess, par2, par3 + 1, par4 - 1, -1))
{
flag2 = true;
}
if (par1IBlockAccess.IsBlockNormalCube(par2, par3, par4 + 1) && IsPoweredOrRepeater(par1IBlockAccess, par2, par3 + 1, par4 + 1, -1))
{
flag3 = true;
}
}
if (!flag2 && !flag1 && !flag && !flag3 && par5 >= 2 && par5 <= 5)
{
return(true);
}
if (par5 == 2 && flag2 && !flag && !flag1)
{
return(true);
}
if (par5 == 3 && flag3 && !flag && !flag1)
{
return(true);
}
if (par5 == 4 && flag && !flag2 && !flag3)
{
return(true);
}
return(par5 == 5 && flag1 && !flag2 && !flag3);
}
