private static void ReportClipping(IBlockAccess world, int entityId, Vector3i playerpos, string playerName)
{
var hasGap = false;
var k = 0;
var l = 0;
for (var i = 0; i < jitterRadius; i++)
{
for (var j = 0; j < jitter[i].Count; j++)
{
if (IsTerrain(world, playerpos + jitter[i][j]))
{
continue;
}
hasGap = true;
k = i;
l = j;
break;
}
if (hasGap)
{
break;
}
}
if (hasGap && k == 0)
{
return;
}
var text = $"CLIP:({entityId}) ({k},{l}) {playerName} {playerpos} - {GameTimer.Instance.ticks}";
ConnectionManager.Instance.GetClients();
GameManager.Instance.GameMessageServer(null, EnumGameMessages.Chat, text, "Server", false, string.Empty, false);
}
public int CalculateSkyLights(IBlockAccess level, ChunkColumn[] chunks)
{
int calcCount = 0;
Stopwatch calcTime = new Stopwatch();
int lastCount = 0;
foreach (var chunk in chunks)
{
if (!_visitedColumns.TryAdd(chunk, true))
{
continue;
}
if (chunk.isAllAir)
{
continue;
}
calcTime.Restart();
if (RecalcSkyLight(chunk, level))
{
//calcCount++;
//var elapsedMilliseconds = calcTime.ElapsedMilliseconds;
//var c = Visits.Sum(pair => pair.Value);
//if (elapsedMilliseconds > 0) Log.Debug($"Recalc skylight chunk {chunk.x}, {chunk.z}, count #{calcCount} (air={chunk.isAllAir}) chunks. Time {elapsedMilliseconds}ms and {c - lastCount} visits");
//lastCount = c;
//PrintVisits();
}
}
//Log.Debug($"Recalc skylight for #{calcCount} chunk. Made {lastCount} visits.");
return(calcCount);
}
/// <inheritdoc />
public override BlockState BlockPlaced(IBlockAccess world, BlockState state, BlockCoordinates position)
{
if (world is World w)
{
if ((w.EntityManager.TryGetBlockEntity(position, out var entity) && !(entity is EnderChestBlockEntity)))
{
w.EntityManager.RemoveBlockEntity(position);
}
if (entity is EnderChestBlockEntity)
{
return(base.BlockPlaced(world, state, position));
}
var ent = new EnderChestBlockEntity(this, w, BlockEntityFactory.EnderChestTexture)
{
X = position.X & 0xf, Y = position.Y & 0xff, Z = position.Z & 0xf
};
w.SetBlockEntity(position.X, position.Y, position.Z, ent);
/*w.EntityManager.AddBlockEntity(
* position, ent);
*
* var chunk = world.GetChunk(position, true);
*
* if (chunk != null)
* {
* chunk.AddBlockEntity(new BlockCoordinates(ent.X, ent.Y, ent.Z), ent);
* }*/
}
return(base.BlockPlaced(world, state, position));
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
if (isFreestanding)
{
return;
}
int l = iblockaccess.getBlockMetadata(i, j, k);
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 (l == 2)
{
setBlockBounds(f2, f, 1.0F - f4, f3, f1, 1.0F);
}
if (l == 3)
{
setBlockBounds(f2, f, 0.0F, f3, f1, f4);
}
if (l == 4)
{
setBlockBounds(1.0F - f4, f, f2, 1.0F, f1, f3);
}
if (l == 5)
{
setBlockBounds(0.0F, f, f2, f4, f1, f3);
}
}
private BlockState Check(IBlockAccess world, BlockCoordinates position, BlockCoordinates updatedBlock, BlockState current)
{
var neighbor = world.GetBlockState(updatedBlock);
var facePos = updatedBlock - position;
var fp = new Vector3(facePos.X, facePos.Y, facePos.Z);
fp.Normalize();
var face = new Vector3(fp.X, fp.Y, fp.Z).GetBlockFace();
var faceString = face.ToString().ToLower();
current.TryGetValue(faceString, out var currentValue);
if (CanAttach(face, neighbor.Block))
{
if (currentValue != "true")
{
return(current.WithProperty(faceString, "true"));
//world.SetBlockState(position, state);
}
}
else
{
if (currentValue != "false")
{
return(current.WithProperty(faceString, "false"));
//world.SetBlockState(position, state);
}
}
return(current);
}
/// <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>
/// 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);
}
public override bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (!torchActive)
{
return false;
}
int i1 = iblockaccess.getBlockMetadata(i, j, k);
if (i1 == 5 && l == 1)
{
return false;
}
if (i1 == 3 && l == 3)
{
return false;
}
if (i1 == 4 && l == 2)
{
return false;
}
if (i1 == 1 && l == 5)
{
return false;
}
return i1 != 2 || l != 4;
}
/// <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);
}
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);
}
//private ConcurrentQueue<LightingItem> LightingQueue { get; }
public SkyLightCalculator(IBlockAccess blockAccess, IChunkManager chunkManager)
{
World = blockAccess;
ChunkQueues = new ConcurrentDictionary <ChunkCoordinates, ConcurrentQueue <LightingItem> >();
//LightingQueue = new ConcurrentQueue<LightingItem>();
ChunkManager = chunkManager;
}
/// <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)
{
bool flag = CanConnectFenceTo(par1IBlockAccess, par2, par3, par4 - 1);
bool flag1 = CanConnectFenceTo(par1IBlockAccess, par2, par3, par4 + 1);
bool flag2 = CanConnectFenceTo(par1IBlockAccess, par2 - 1, par3, par4);
bool flag3 = CanConnectFenceTo(par1IBlockAccess, par2 + 1, par3, par4);
float f = 0.375F;
float f1 = 0.625F;
float f2 = 0.375F;
float f3 = 0.625F;
if (flag)
{
f2 = 0.0F;
}
if (flag1)
{
f3 = 1.0F;
}
if (flag2)
{
f = 0.0F;
}
if (flag3)
{
f1 = 1.0F;
}
SetBlockBounds(f, 0.0F, f2, f1, 1.0F, f3);
}
/// <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 override bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (!torchActive)
{
return(false);
}
int i1 = iblockaccess.getBlockMetadata(i, j, k);
if (i1 == 5 && l == 1)
{
return(false);
}
if (i1 == 3 && l == 3)
{
return(false);
}
if (i1 == 4 && l == 2)
{
return(false);
}
if (i1 == 1 && l == 5)
{
return(false);
}
return(i1 != 2 || l != 4);
}
private Color GetGrassBiomeColor(IBlockAccess access, int x, int y, int z)
{
var biome = access.GetBiome(new BlockCoordinates(x, y, z));
return(Resources.ResourcePack.GetGrassColor(
biome.Temperature, biome.Downfall, y));
}
public LevelNavigator(Entity entity, IBlockAccess level, double distance, Dictionary <ImprovedTile, Block> blockCache)
{
_entity = entity;
_level = level;
_distance = distance;
_blockCache = blockCache;
}
/// <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>
/// 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 (par1IBlockAccess.GetBlockId(par2, par3, par4) == BlockID)
{
return(false);
}
bool flag = par1IBlockAccess.GetBlockId(par2 - 1, par3, par4) == BlockID && par1IBlockAccess.GetBlockId(par2 - 2, par3, par4) != BlockID;
bool flag1 = par1IBlockAccess.GetBlockId(par2 + 1, par3, par4) == BlockID && par1IBlockAccess.GetBlockId(par2 + 2, par3, par4) != BlockID;
bool flag2 = par1IBlockAccess.GetBlockId(par2, par3, par4 - 1) == BlockID && par1IBlockAccess.GetBlockId(par2, par3, par4 - 2) != BlockID;
bool flag3 = par1IBlockAccess.GetBlockId(par2, par3, par4 + 1) == BlockID && par1IBlockAccess.GetBlockId(par2, par3, par4 + 2) != BlockID;
bool flag4 = flag || flag1;
bool flag5 = flag2 || flag3;
if (flag4 && par5 == 4)
{
return(true);
}
if (flag4 && par5 == 5)
{
return(true);
}
if (flag5 && par5 == 2)
{
return(true);
}
return(flag5 && par5 == 3);
}
/// <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)
{
TileEntityPiston tileentitypiston = GetTileEntityAtLocation(par1IBlockAccess, par2, par3, par4);
if (tileentitypiston != null)
{
Block block = Block.BlocksList[tileentitypiston.GetStoredBlockID()];
if (block == null || block == this)
{
return;
}
block.SetBlockBoundsBasedOnState(par1IBlockAccess, par2, par3, par4);
float f = tileentitypiston.GetProgress(0.0F);
if (tileentitypiston.IsExtending())
{
f = 1.0F - f;
}
int i = tileentitypiston.GetPistonOrientation();
MinX = block.MinX - (Facing.OffsetsXForSide[i] * f);
MinY = block.MinY - (Facing.OffsetsYForSide[i] * f);
MinZ = block.MinZ - (Facing.OffsetsZForSide[i] * f);
MaxX = block.MaxX - (Facing.OffsetsXForSide[i] * f);
MaxY = block.MaxY - (Facing.OffsetsYForSide[i] * f);
MaxZ = block.MaxZ - (Facing.OffsetsZForSide[i] * f);
}
}
public Pathfinder(IBlockAccess iblockaccess)
{
path = new Path();
pointMap = new MCHashTable();
pathOptions = new PathPoint[32];
worldMap = iblockaccess;
}
/// <summary>
/// How bright to render this block based on the light its receiving. Args: iBlockAccess, x, y, z
/// </summary>
public override float GetBlockBrightness(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
float f = par1IBlockAccess.GetLightBrightness(par2, par3, par4);
float f1 = par1IBlockAccess.GetLightBrightness(par2, par3 + 1, par4);
return(f <= f1 ? f1 : f);
}
/// <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)
{
if (BlockMaterial == Material.Water)
{
int i = 0;
int j = 0;
int k = 0;
for (int l = -1; l <= 1; l++)
{
for (int i1 = -1; i1 <= 1; i1++)
{
int j1 = par1IBlockAccess.GetBiomeGenForCoords(par2 + i1, par4 + l).WaterColorMultiplier;
i += (j1 & 0xff0000) >> 16;
j += (j1 & 0xff00) >> 8;
k += j1 & 0xff;
}
}
return((i / 9 & 0xff) << 16 | (j / 9 & 0xff) << 8 | k / 9 & 0xff);
}
else
{
return(0xffffff);
}
}
public static bool SetBlock(this IBlockAccess world, int x, int y, int z, string blockName, params string[] args)
{
IBlock block = GameData.JavaEdition.GetBlock(blockName);
if (args == null || args.Length == 0)
{
return(world.SetBlock(x, y, z, block.DefaultBlockSet));
}
if (args.Length == 1)
{
TagCompound tag = NBTFile.FromJson(args[0]);
return(world.SetBlock(x, y, z, new BlockSet(block, tag)));
}
else if ((args.Length & 1) == 0)
{
Dictionary <string, string> ps1 = PropertyConverter.From(args);
foreach (string key in block.DefaultBlockSet.Properties.Keys)
{
if (!ps1.ContainsKey(key))
{
ps1.Add(key, block.DefaultBlockSet.Properties[key]);
}
}
return(world.SetBlock(x, y, z, new BlockSet(block, ps1)));
}
return(world.SetBlock(x, y, z, block.DefaultBlockSet));
}
/// <inheritdoc />
public bool Passes(IBlockAccess world, Vector3 position, string rule, string value)
{
if (!MultiPartModelHelper.TryGetBlockface(rule, out BlockFace face))
{
return(false);
}
Vector3 offset = face.GetVector3();
offset = position + offset;
if (value == "side|up")
{
return(IsRedstoneWire(world, offset) ||
IsRedstoneWire(world, offset + Vector3.Down));
}
else if (value == "up")
{
return(IsRedstoneWire(world, offset + Vector3.Up));
}
else if (value == "none")
{
return(!IsRedstoneWire(world, offset));
}
return(false);
}
public override VerticesResult GetVertices(IBlockAccess world, Vector3 position, Block baseBlock)
{
List <BlockShaderVertex> vertices = new List <BlockShaderVertex>();
List <int> indexes = new List <int>();
List <int> animatedIndexes = new List <int>();
for (var index = 0; index < Models.Length; index++)
{
var model = Models[index];
model.Scale = 1f - (index * 0.001f);
var verts = model.GetVertices(world, position, baseBlock);
for (int i = 0; i < verts.Indexes.Length; i++)
{
indexes.Add(vertices.Count + verts.Indexes[i]);
}
if (verts.AnimatedIndexes != null)
{
for (int i = 0; i < verts.AnimatedIndexes.Length; i++)
{
animatedIndexes.Add(vertices.Count + verts.AnimatedIndexes[i]);
}
}
vertices.AddRange(verts.Vertices);
}
return(new VerticesResult(vertices.ToArray(), indexes.ToArray(), animatedIndexes.Count > 0 ? animatedIndexes.ToArray() : null));
}
public virtual bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (l == 0 && minY > 0.0D)
{
return(true);
}
if (l == 1 && maxY < 1.0D)
{
return(true);
}
if (l == 2 && minZ > 0.0D)
{
return(true);
}
if (l == 3 && maxZ < 1.0D)
{
return(true);
}
if (l == 4 && minX > 0.0D)
{
return(true);
}
if (l == 5 && maxX < 1.0D)
{
return(true);
}
else
{
return(!iblockaccess.isBlockOpaqueCube(i, j, k));
}
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
if (isFreestanding)
{
return;
}
int l = iblockaccess.getBlockMetadata(i, j, k);
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 (l == 2)
{
setBlockBounds(f2, f, 1.0F - f4, f3, f1, 1.0F);
}
if (l == 3)
{
setBlockBounds(f2, f, 0.0F, f3, f1, f4);
}
if (l == 4)
{
setBlockBounds(1.0F - f4, f, f2, 1.0F, f1, f3);
}
if (l == 5)
{
setBlockBounds(0.0F, f, f2, f4, f1, f3);
}
}
public Pathfinder(IBlockAccess iblockaccess)
{
path = new Path();
pointMap = new MCHashTable();
pathOptions = new PathPoint[32];
worldMap = iblockaccess;
}
/// <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);
}
protected int GetAverageLiquidLevels(IBlockAccess world, BlockCoordinates position, out BlockCoordinates lowest, out int lowestLevel)
{
lowest = BlockCoordinates.Up;
lowestLevel = 7;
int level = 0;
for (int xx = -1; xx < 1; xx++)
{
for (int zz = -1; zz < 1; zz++)
{
if (world.GetBlockStates(position.X + xx, position.Y + 1, position.Z + zz).Any(
x =>
{
if (x.State?.VariantMapper.Model is LiquidBlockModel)
{
return(true);
}
return(false);
}))
{
return(8);
}
foreach (var bs in world.GetBlockStates(position.X + xx, position.Y, position.Z + zz))
{
var b = bs.State;
if (!b.Block.Renderable || !(b?.VariantMapper.Model is LiquidBlockModel l))
{
continue;
}
if (l.IsLava != IsLava)
{
continue;
}
if (TryGetLevel(b, out int lvl))
{
if (lvl > level)
{
level = lvl;
}
if (lvl < lowestLevel)
{
lowestLevel = lvl;
lowest = new BlockCoordinates(position.X + xx, position.Y, position.Z + zz);
}
}
//break;
}
}
}
return(level);
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockMetadata(i, j, k) & 7;
float f = 0.1875F;
if (l == 1)
{
setBlockBounds(0.0F, 0.2F, 0.5F - f, f * 2.0F, 0.8F, 0.5F + f);
}
else if (l == 2)
{
setBlockBounds(1.0F - f * 2.0F, 0.2F, 0.5F - f, 1.0F, 0.8F, 0.5F + f);
}
else if (l == 3)
{
setBlockBounds(0.5F - f, 0.2F, 0.0F, 0.5F + f, 0.8F, f * 2.0F);
}
else if (l == 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>
/// 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);
}
}
public override bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
int i1 = iblockaccess.getBlockId(i, j, k);
if (!field_6084_a && i1 == blockID)
{
return false;
}
else
{
return base.shouldSideBeRendered(iblockaccess, i, j, k, l);
}
}
public static bool isPowerProviderOrWire(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockId(i, j, k);
if (l == redstoneWire.blockID)
{
return true;
}
if (l == 0)
{
return false;
}
return blocksList[l].canProvidePower();
}
public override bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (!field_22015_c)
{
return false;
}
int i1 = iblockaccess.getBlockMetadata(i, j, k) & 3;
if (i1 == 0 && l == 3)
{
return true;
}
if (i1 == 1 && l == 4)
{
return true;
}
if (i1 == 2 && l == 2)
{
return true;
}
return i1 == 3 && l == 5;
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
if (iblockaccess.getBlockId(i - 1, j, k) == blockID || iblockaccess.getBlockId(i + 1, j, k) == blockID)
{
float f = 0.5F;
float f2 = 0.125F;
setBlockBounds(0.5F - f, 0.0F, 0.5F - f2, 0.5F + f, 1.0F, 0.5F + f2);
}
else
{
float f1 = 0.125F;
float f3 = 0.5F;
setBlockBounds(0.5F - f1, 0.0F, 0.5F - f3, 0.5F + f1, 1.0F, 0.5F + f3);
}
}
public override bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
return true;
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockMetadata(i, j, k);
int i1 = l & 7;
bool flag = (l & 8) > 0;
float f = 0.375F;
float f1 = 0.625F;
float f2 = 0.1875F;
float f3 = 0.125F;
if (flag)
{
f3 = 0.0625F;
}
if (i1 == 1)
{
setBlockBounds(0.0F, f, 0.5F - f2, f3, f1, 0.5F + f2);
}
else if (i1 == 2)
{
setBlockBounds(1.0F - f3, f, 0.5F - f2, 1.0F, f1, 0.5F + f2);
}
else if (i1 == 3)
{
setBlockBounds(0.5F - f2, f, 0.0F, 0.5F + f2, f1, f3);
}
else if (i1 == 4)
{
setBlockBounds(0.5F - f2, f, 1.0F - f3, 0.5F + f2, f1, 1.0F);
}
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
public virtual bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
return false;
}
public override bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
return base.shouldSideBeRendered(iblockaccess, i, j, k, 1 - l);
}
public virtual bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (l == 0 && minY > 0.0D)
{
return true;
}
if (l == 1 && maxY < 1.0D)
{
return true;
}
if (l == 2 && minZ > 0.0D)
{
return true;
}
if (l == 3 && maxZ < 1.0D)
{
return true;
}
if (l == 4 && minX > 0.0D)
{
return true;
}
if (l == 5 && maxX < 1.0D)
{
return true;
}
else
{
return !iblockaccess.isBlockOpaqueCube(i, j, k);
}
}
public virtual void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
bool flag = iblockaccess.getBlockMetadata(i, j, k) == 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);
}
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockMetadata(i, j, k);
float f = 0.0625F;
float f1 = (1 + l*2)/16F;
float f2 = 0.5F;
setBlockBounds(f1, 0.0F, f, 1.0F - f, f2, 1.0F - f);
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockMetadata(i, j, k);
if (l >= 2 && l <= 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);
}
}
public override bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (!wiresProvidePower)
{
return false;
}
if (iblockaccess.getBlockMetadata(i, j, k) == 0)
{
return false;
}
if (l == 1)
{
return true;
}
bool flag = isPowerProviderOrWire(iblockaccess, i - 1, j, k) ||
!iblockaccess.isBlockOpaqueCube(i - 1, j, k) &&
isPowerProviderOrWire(iblockaccess, i - 1, j - 1, k);
bool flag1 = isPowerProviderOrWire(iblockaccess, i + 1, j, k) ||
!iblockaccess.isBlockOpaqueCube(i + 1, j, k) &&
isPowerProviderOrWire(iblockaccess, i + 1, j - 1, k);
bool flag2 = isPowerProviderOrWire(iblockaccess, i, j, k - 1) ||
!iblockaccess.isBlockOpaqueCube(i, j, k - 1) &&
isPowerProviderOrWire(iblockaccess, i, j - 1, k - 1);
bool flag3 = isPowerProviderOrWire(iblockaccess, i, j, k + 1) ||
!iblockaccess.isBlockOpaqueCube(i, j, k + 1) &&
isPowerProviderOrWire(iblockaccess, i, j - 1, k + 1);
if (!iblockaccess.isBlockOpaqueCube(i, j + 1, k))
{
if (iblockaccess.isBlockOpaqueCube(i - 1, j, k) && isPowerProviderOrWire(iblockaccess, i - 1, j + 1, k))
{
flag = true;
}
if (iblockaccess.isBlockOpaqueCube(i + 1, j, k) && isPowerProviderOrWire(iblockaccess, i + 1, j + 1, k))
{
flag1 = true;
}
if (iblockaccess.isBlockOpaqueCube(i, j, k - 1) && isPowerProviderOrWire(iblockaccess, i, j + 1, k - 1))
{
flag2 = true;
}
if (iblockaccess.isBlockOpaqueCube(i, j, k + 1) && isPowerProviderOrWire(iblockaccess, i, j + 1, k + 1))
{
flag3 = true;
}
}
if (!flag2 && !flag1 && !flag && !flag3 && l >= 2 && l <= 5)
{
return true;
}
if (l == 2 && flag2 && !flag && !flag1)
{
return true;
}
if (l == 3 && flag3 && !flag && !flag1)
{
return true;
}
if (l == 4 && flag && !flag2 && !flag3)
{
return true;
}
return l == 5 && flag1 && !flag2 && !flag3;
}
public override bool shouldSideBeRendered(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
if (this != stairSingle)
{
base.shouldSideBeRendered(iblockaccess, i, j, k, l);
}
if (l == 1)
{
return true;
}
if (!base.shouldSideBeRendered(iblockaccess, i, j, k, l))
{
return false;
}
if (l == 0)
{
return true;
}
else
{
return iblockaccess.getBlockId(i, j, k) != blockID;
}
}
public override bool isPoweringTo(IBlockAccess iblockaccess, int i, int j, int k, int l)
{
return (iblockaccess.getBlockMetadata(i, j, k) & 8) > 0;
}
public override void setBlockBoundsBasedOnState(IBlockAccess iblockaccess, int i, int j, int k)
{
int l = iblockaccess.getBlockMetadata(i, j, k) & 7;
float f = 0.1875F;
if (l == 1)
{
setBlockBounds(0.0F, 0.2F, 0.5F - f, f*2.0F, 0.8F, 0.5F + f);
}
else if (l == 2)
{
setBlockBounds(1.0F - f*2.0F, 0.2F, 0.5F - f, 1.0F, 0.8F, 0.5F + f);
}
else if (l == 3)
{
setBlockBounds(0.5F - f, 0.2F, 0.0F, 0.5F + f, 0.8F, f*2.0F);
}
else if (l == 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);
}
}
