public override void OnNeighborBlockChanged(CellFace cellFace, int neighborX, int neighborY, int neighborZ)
{
int cellValue = base.SubsystemElectricity.SubsystemTerrain.Terrain.GetCellValue(cellFace.X, cellFace.Y, cellFace.Z);
int num = Terrain.ExtractContents(cellValue);
if (!(BlocksManager.Blocks[num] is WireBlock))
{
return;
}
int wireFacesBitmask = WireBlock.GetWireFacesBitmask(cellValue);
int num2 = wireFacesBitmask;
if (WireBlock.WireExistsOnFace(cellValue, cellFace.Face))
{
Point3 point = CellFace.FaceToPoint3(cellFace.Face);
int cellValue2 = base.SubsystemElectricity.SubsystemTerrain.Terrain.GetCellValue(cellFace.X - point.X, cellFace.Y - point.Y, cellFace.Z - point.Z);
Block block = BlocksManager.Blocks[Terrain.ExtractContents(cellValue2)];
if (!block.IsCollidable || block.IsTransparent)
{
num2 &= ~(1 << cellFace.Face);
}
}
if (num2 == 0)
{
base.SubsystemElectricity.SubsystemTerrain.DestroyCell(0, cellFace.X, cellFace.Y, cellFace.Z, 0, noDrop: false, noParticleSystem: false);
}
else if (num2 != wireFacesBitmask)
{
int newValue = WireBlock.SetWireFacesBitmask(cellValue, num2);
base.SubsystemElectricity.SubsystemTerrain.DestroyCell(0, cellFace.X, cellFace.Y, cellFace.Z, newValue, noDrop: false, noParticleSystem: false);
}
}
public ElectricConnectorType?GetConnectorType(SubsystemTerrain terrain, int value, int face, int connectorFace, int x, int y, int z)
{
int data = Terrain.ExtractData(value);
int rotation = GetRotation(data);
int designIndex = GetDesignIndex(data);
FurnitureDesign design = terrain.SubsystemFurnitureBlockBehavior.GetDesign(designIndex);
if (design != null)
{
int num = CellFace.OppositeFace((face < 4) ? ((face - rotation + 4) % 4) : face);
if ((design.MountingFacesMask & (1 << num)) != 0 && SubsystemElectricity.GetConnectorDirection(face, 0, connectorFace).HasValue)
{
Point3 point = CellFace.FaceToPoint3(face);
int cellValue = terrain.Terrain.GetCellValue(x - point.X, y - point.Y, z - point.Z);
if (!BlocksManager.Blocks[Terrain.ExtractContents(cellValue)].IsFaceTransparent(terrain, CellFace.OppositeFace(num), cellValue))
{
if (design.InteractionMode == FurnitureInteractionMode.Multistate || design.InteractionMode == FurnitureInteractionMode.ConnectedMultistate)
{
return(ElectricConnectorType.Input);
}
if (design.InteractionMode == FurnitureInteractionMode.ElectricButton || design.InteractionMode == FurnitureInteractionMode.ElectricSwitch)
{
return(ElectricConnectorType.Output);
}
}
}
}
return(null);
}
public void InitializeFireDataTime(FireData fireData, int face)
{
Point3 point = CellFace.FaceToPoint3(face);
int x = fireData.Point.X + point.X;
int y = fireData.Point.Y + point.Y;
int z = fireData.Point.Z + point.Z;
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(x, y, z);
Block block = BlocksManager.Blocks[cellContents];
switch (face)
{
case 4:
break;
case 0:
fireData.Time0 = block.FireDuration * m_random.Float(0.75f, 1.25f);
break;
case 1:
fireData.Time1 = block.FireDuration * m_random.Float(0.75f, 1.25f);
break;
case 2:
fireData.Time2 = block.FireDuration * m_random.Float(0.75f, 1.25f);
break;
case 3:
fireData.Time3 = block.FireDuration * m_random.Float(0.75f, 1.25f);
break;
case 5:
fireData.Time5 = block.FireDuration * m_random.Float(0.75f, 1.25f);
break;
}
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
int num = Terrain.ExtractContents(value);
int data = Terrain.ExtractData(value);
int num2 = Terrain.ExtractContents(raycastResult.Value);
int data2 = Terrain.ExtractData(raycastResult.Value);
BlockPlacementData result;
if (num2 == num && ((GetIsTop(data2) && raycastResult.CellFace.Face == 5) || (!GetIsTop(data2) && raycastResult.CellFace.Face == 4)))
{
int value2 = Terrain.MakeBlockValue(m_fullBlockIndex, 0, 0);
IPaintableBlock paintableBlock = BlocksManager.Blocks[m_fullBlockIndex] as IPaintableBlock;
if (paintableBlock != null)
{
int?color = GetColor(data);
value2 = paintableBlock.Paint(subsystemTerrain, value2, color);
}
CellFace cellFace = raycastResult.CellFace;
cellFace.Point -= CellFace.FaceToPoint3(cellFace.Face);
result = default(BlockPlacementData);
result.Value = value2;
result.CellFace = cellFace;
return(result);
}
bool isTop = (raycastResult.CellFace.Face >= 4) ? (raycastResult.CellFace.Face == 5) : (raycastResult.HitPoint().Y - (float)raycastResult.CellFace.Y > 0.5f);
result = default(BlockPlacementData);
result.Value = Terrain.MakeBlockValue(BlockIndex, 0, SetIsTop(data, isTop));
result.CellFace = raycastResult.CellFace;
return(result);
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int cellValueFast = base.SubsystemTerrain.Terrain.GetCellValueFast(x, y, z);
switch (Terrain.ExtractContents(cellValueFast))
{
case 31:
{
Point3 point = CellFace.FaceToPoint3(Terrain.ExtractData(cellValueFast));
int x2 = x - point.X;
int y2 = y - point.Y;
int z2 = z - point.Z;
int cellContents2 = base.SubsystemTerrain.Terrain.GetCellContents(x2, y2, z2);
if (!BlocksManager.Blocks[cellContents2].IsCollidable)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
break;
}
case 132:
{
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(x, y - 1, z);
if (!BlocksManager.Blocks[cellContents].IsCollidable)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
break;
}
}
}
public void MovingBlocksCollidedWithTerrain(IMovingBlockSet movingBlockSet, Point3 p)
{
if (!(movingBlockSet.Id == "Piston"))
{
return;
}
Point3 point = (Point3)movingBlockSet.Tag;
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);
if (Terrain.ExtractContents(cellValue) != 237)
{
return;
}
Point3 point2 = CellFace.FaceToPoint3(PistonBlock.GetFace(Terrain.ExtractData(cellValue)));
int num = p.X * point2.X + p.Y * point2.Y + p.Z * point2.Z;
int num2 = point.X * point2.X + point.Y * point2.Y + point.Z * point2.Z;
if (num > num2)
{
if (IsBlockBlocking(base.SubsystemTerrain.Terrain.GetCellValue(p.X, p.Y, p.Z)))
{
movingBlockSet.Stop();
}
else
{
base.SubsystemTerrain.DestroyCell(0, p.X, p.Y, p.Z, 0, noDrop: false, noParticleSystem: false);
}
}
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x, y, z);
int num = Terrain.ExtractContents(cellValue);
Block obj = BlocksManager.Blocks[num];
int data = Terrain.ExtractData(cellValue);
if (obj is TrapdoorBlock)
{
int rotation = TrapdoorBlock.GetRotation(data);
bool upsideDown = TrapdoorBlock.GetUpsideDown(data);
bool flag = false;
Point3 point = CellFace.FaceToPoint3(rotation);
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(x - point.X, y - point.Y, z - point.Z);
flag |= !BlocksManager.Blocks[cellContents].IsTransparent;
if (upsideDown)
{
int cellContents2 = base.SubsystemTerrain.Terrain.GetCellContents(x, y + 1, z);
flag |= !BlocksManager.Blocks[cellContents2].IsTransparent;
int cellContents3 = base.SubsystemTerrain.Terrain.GetCellContents(x - point.X, y - point.Y + 1, z - point.Z);
flag |= !BlocksManager.Blocks[cellContents3].IsTransparent;
}
else
{
int cellContents4 = base.SubsystemTerrain.Terrain.GetCellContents(x, y - 1, z);
flag |= !BlocksManager.Blocks[cellContents4].IsTransparent;
int cellContents5 = base.SubsystemTerrain.Terrain.GetCellContents(x - point.X, y - point.Y - 1, z - point.Z);
flag |= !BlocksManager.Blocks[cellContents5].IsTransparent;
}
if (!flag)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
}
public bool SetCellOnFire(int x, int y, int z, float fireExpandability)
{
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x, y, z);
int num = Terrain.ExtractContents(cellValue);
if (BlocksManager.Blocks[num].FireDuration == 0f)
{
return(false);
}
bool result = false;
for (int i = 0; i < 5; i++)
{
Point3 point = CellFace.FaceToPoint3(i);
int cellValue2 = base.SubsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
int num2 = Terrain.ExtractContents(cellValue2);
if (num2 == 0 || num2 == 104 || num2 == 61)
{
int num3 = (num2 == 104) ? Terrain.ExtractData(cellValue2) : 0;
int num4 = CellFace.OppositeFace(i);
num3 |= ((1 << num4) & 0xF);
cellValue = Terrain.ReplaceData(Terrain.ReplaceContents(0, 104), num3);
AddFire(x + point.X, y + point.Y, z + point.Z, fireExpandability);
base.SubsystemTerrain.ChangeCell(x + point.X, y + point.Y, z + point.Z, cellValue);
result = true;
}
}
return(result);
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int cellValueFast = base.SubsystemTerrain.Terrain.GetCellValueFast(x, y, z);
int num = Terrain.ExtractContents(cellValueFast);
int data = Terrain.ExtractData(cellValueFast);
Block block = BlocksManager.Blocks[num];
if (block is AttachedSignBlock)
{
Point3 point = CellFace.FaceToPoint3(AttachedSignBlock.GetFace(data));
int x2 = x - point.X;
int y2 = y - point.Y;
int z2 = z - point.Z;
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(x2, y2, z2);
if (!BlocksManager.Blocks[cellContents].IsCollidable)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
else if (block is PostedSignBlock)
{
int num2 = PostedSignBlock.GetHanging(data) ? base.SubsystemTerrain.Terrain.GetCellContents(x, y + 1, z) : base.SubsystemTerrain.Terrain.GetCellContents(x, y - 1, z);
if (!BlocksManager.Blocks[num2].IsCollidable)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
}
public float CalculateVoltage()
{
CellFace cellFace = base.CellFaces[0];
Point3 point = CellFace.FaceToPoint3(cellFace.Face);
int cellLight = base.SubsystemElectricity.SubsystemTerrain.Terrain.GetCellLight(cellFace.X, cellFace.Y, cellFace.Z);
int cellLight2 = base.SubsystemElectricity.SubsystemTerrain.Terrain.GetCellLight(cellFace.X + point.X, cellFace.Y + point.Y, cellFace.Z + point.Z);
return((float)MathUtils.Max(cellLight, cellLight2) / 15f);
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
Vector3 forward = Matrix.CreateFromQuaternion(componentMiner.ComponentCreature.ComponentCreatureModel.EyeRotation).Forward;
float num = Vector3.Dot(forward, Vector3.UnitZ);
float num2 = Vector3.Dot(forward, Vector3.UnitX);
float num3 = Vector3.Dot(forward, -Vector3.UnitZ);
float num4 = Vector3.Dot(forward, -Vector3.UnitX);
int num5 = 0;
if (num == MathUtils.Max(num, num2, num3, num4))
{
num5 = 2;
}
else if (num2 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 3;
}
else if (num3 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 0;
}
else if (num4 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 1;
}
Point3 point = CellFace.FaceToPoint3(raycastResult.CellFace.Face);
int num6 = raycastResult.CellFace.X + point.X;
int y = raycastResult.CellFace.Y + point.Y;
int num7 = raycastResult.CellFace.Z + point.Z;
bool rightHanded = true;
switch (num5)
{
case 0:
rightHanded = BlocksManager.Blocks[subsystemTerrain.Terrain.GetCellContents(num6 - 1, y, num7)].IsTransparent;
break;
case 1:
rightHanded = BlocksManager.Blocks[subsystemTerrain.Terrain.GetCellContents(num6, y, num7 + 1)].IsTransparent;
break;
case 2:
rightHanded = BlocksManager.Blocks[subsystemTerrain.Terrain.GetCellContents(num6 + 1, y, num7)].IsTransparent;
break;
case 3:
rightHanded = BlocksManager.Blocks[subsystemTerrain.Terrain.GetCellContents(num6, y, num7 - 1)].IsTransparent;
break;
}
int data = SetRightHanded(SetOpen(SetRotation(0, num5), open: false), rightHanded);
BlockPlacementData result = default(BlockPlacementData);
result.Value = Terrain.ReplaceData(Terrain.ReplaceContents(0, BlockIndex), data);
result.CellFace = raycastResult.CellFace;
return(result);
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
Point3 point = CellFace.FaceToPoint3(Terrain.ExtractData(base.SubsystemTerrain.Terrain.GetCellValue(x, y, z)));
int cellContents = base.SubsystemTerrain.Terrain.GetCellContents(x - point.X, y - point.Y, z - point.Z);
if (BlocksManager.Blocks[cellContents].IsTransparent)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
var cellFace = raycastResult.CellFace;
var p = CellFace.FaceToPoint3(cellFace.Face);
var device = GetDevice(cellFace.X + p.X, cellFace.Y + p.X, cellFace.Z + p.Z, value);
return device != null ? device.GetPlacementValue(subsystemTerrain, componentMiner, value, raycastResult) : new BlockPlacementData
{
Value = value,
CellFace = cellFace
};
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
base.OnNeighborBlockChanged(x, y, z, neighborX, neighborY, neighborZ);
int face = BottomSuckerBlock.GetFace(Terrain.ExtractData(base.SubsystemTerrain.Terrain.GetCellValue(x, y, z)));
Point3 point = CellFace.FaceToPoint3(CellFace.OppositeFace(face));
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
if (!IsSupport(cellValue, face))
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int face = LadderBlock.GetFace(Terrain.ExtractData(base.SubsystemTerrain.Terrain.GetCellValue(x, y, z)));
Point3 point = CellFace.FaceToPoint3(face);
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x - point.X, y - point.Y, z - point.Z);
int num = Terrain.ExtractContents(cellValue);
if (BlocksManager.Blocks[num].IsFaceTransparent(base.SubsystemTerrain, face, cellValue))
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: false, noParticleSystem: false);
}
}
public override void OnBlockRemoved(int value, int newValue, int x, int y, int z)
{
int num = Terrain.ExtractContents(value);
int data = Terrain.ExtractData(value);
switch (num)
{
case 237:
{
StopPiston(new Point3(x, y, z));
int face2 = PistonBlock.GetFace(data);
Point3 point2 = CellFace.FaceToPoint3(face2);
int cellValue3 = m_subsystemTerrain.Terrain.GetCellValue(x + point2.X, y + point2.Y, z + point2.Z);
int num4 = Terrain.ExtractContents(cellValue3);
int data4 = Terrain.ExtractData(cellValue3);
if (num4 == 238 && PistonHeadBlock.GetFace(data4) == face2)
{
m_subsystemTerrain.DestroyCell(0, x + point2.X, y + point2.Y, z + point2.Z, 0, noDrop: false, noParticleSystem: false);
}
break;
}
case 238:
if (!m_allowPistonHeadRemove)
{
int face = PistonHeadBlock.GetFace(data);
Point3 point = CellFace.FaceToPoint3(face);
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
int cellValue2 = m_subsystemTerrain.Terrain.GetCellValue(x - point.X, y - point.Y, z - point.Z);
int num2 = Terrain.ExtractContents(cellValue);
int num3 = Terrain.ExtractContents(cellValue2);
int data2 = Terrain.ExtractData(cellValue);
int data3 = Terrain.ExtractData(cellValue2);
if (num2 == 238 && PistonHeadBlock.GetFace(data2) == face)
{
m_subsystemTerrain.DestroyCell(0, x + point.X, y + point.Y, z + point.Z, 0, noDrop: false, noParticleSystem: false);
}
if (num3 == 237 && PistonBlock.GetFace(data3) == face)
{
m_subsystemTerrain.DestroyCell(0, x - point.X, y - point.Y, z - point.Z, 0, noDrop: false, noParticleSystem: false);
}
else if (num3 == 238 && PistonHeadBlock.GetFace(data3) == face)
{
m_subsystemTerrain.DestroyCell(0, x - point.X, y - point.Y, z - point.Z, 0, noDrop: false, noParticleSystem: false);
}
}
break;
}
}
public override void OnNeighborBlockChanged(CellFace cellFace, int neighborX, int neighborY, int neighborZ)
{
Point3 point = CellFace.FaceToPoint3(cellFace.Face);
int x = cellFace.X - point.X;
int y = cellFace.Y - point.Y;
int z = cellFace.Z - point.Z;
if (base.SubsystemElectricity.SubsystemTerrain.Terrain.IsCellValid(x, y, z))
{
int cellValue = base.SubsystemElectricity.SubsystemTerrain.Terrain.GetCellValue(x, y, z);
Block block = BlocksManager.Blocks[Terrain.ExtractContents(cellValue)];
if ((!block.IsCollidable || block.IsFaceTransparent(base.SubsystemElectricity.SubsystemTerrain, cellFace.Face, cellValue)) && (cellFace.Face != 4 || !(block is FenceBlock)))
{
base.SubsystemElectricity.SubsystemTerrain.DestroyCell(0, cellFace.X, cellFace.Y, cellFace.Z, 0, noDrop: false, noParticleSystem: false);
}
}
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
Point3 point = raycastResult.CellFace.Point + CellFace.FaceToPoint3(raycastResult.CellFace.Face);
int cellValue = subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);
int num = Terrain.ExtractContents(cellValue);
int data = Terrain.ExtractData(cellValue);
BlockPlacementData result;
if (BlocksManager.Blocks[num] is WaterBlock)
{
result = default(BlockPlacementData);
result.CellFace = raycastResult.CellFace;
result.Value = Terrain.MakeBlockValue(BlockIndex, 0, data);
return(result);
}
result = default(BlockPlacementData);
return(result);
}
public override void OnNeighborBlockChanged(int x, int y, int z, int neighborX, int neighborY, int neighborZ)
{
int face = IvyBlock.GetFace(Terrain.ExtractData(base.SubsystemTerrain.Terrain.GetCellValue(x, y, z)));
bool flag = false;
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x, y + 1, z);
if (Terrain.ExtractContents(cellValue) == 197 && IvyBlock.GetFace(Terrain.ExtractData(cellValue)) == face)
{
flag = true;
}
if (!flag)
{
Point3 point = CellFace.FaceToPoint3(face);
int cellValue2 = base.SubsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
if (!BlocksManager.Blocks[Terrain.ExtractContents(cellValue2)].IsCollidable)
{
base.SubsystemTerrain.DestroyCell(0, x, y, z, 0, noDrop: true, noParticleSystem: false);
}
}
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
Point3 point = CellFace.FaceToPoint3(raycastResult.CellFace.Face);
int cellValue = subsystemTerrain.Terrain.GetCellValue(raycastResult.CellFace.X + point.X, raycastResult.CellFace.Y + point.Y, raycastResult.CellFace.Z + point.Z);
int num = Terrain.ExtractContents(cellValue);
Block block = BlocksManager.Blocks[num];
int wireFacesBitmask = GetWireFacesBitmask(cellValue);
int num2 = wireFacesBitmask | (1 << raycastResult.CellFace.Face);
BlockPlacementData result;
if (num2 != wireFacesBitmask || !(block is WireBlock))
{
result = default(BlockPlacementData);
result.Value = SetWireFacesBitmask(value, num2);
result.CellFace = raycastResult.CellFace;
return(result);
}
result = default(BlockPlacementData);
return(result);
}
public bool IsCellOnFire(int x, int y, int z)
{
for (int i = 0; i < 4; i++)
{
Point3 point = CellFace.FaceToPoint3(i);
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x + point.X, y + point.Y, z + point.Z);
if (Terrain.ExtractContents(cellValue) == 104)
{
int num = Terrain.ExtractData(cellValue);
int num2 = CellFace.OppositeFace(i);
if ((num & (1 << num2)) != 0)
{
return(true);
}
}
}
int cellValue2 = base.SubsystemTerrain.Terrain.GetCellValue(x, y + 1, z);
if (Terrain.ExtractContents(cellValue2) == 104 && Terrain.ExtractData(cellValue2) == 0)
{
return(true);
}
return(false);
}
public void UpdateMovableBlocks()
{
foreach (IMovingBlockSet movingBlockSet in m_subsystemMovingBlocks.MovingBlockSets)
{
if (movingBlockSet.Id == "Piston")
{
Point3 point = (Point3)movingBlockSet.Tag;
int cellValue = m_subsystemTerrain.Terrain.GetCellValue(point.X, point.Y, point.Z);
if (Terrain.ExtractContents(cellValue) == 237)
{
int data = Terrain.ExtractData(cellValue);
PistonMode mode = PistonBlock.GetMode(data);
int face = PistonBlock.GetFace(data);
Point3 p = CellFace.FaceToPoint3(face);
int num = int.MaxValue;
foreach (MovingBlock block in movingBlockSet.Blocks)
{
num = MathUtils.Min(num, block.Offset.X * p.X + block.Offset.Y * p.Y + block.Offset.Z * p.Z);
}
float num2 = movingBlockSet.Position.X * (float)p.X + movingBlockSet.Position.Y * (float)p.Y + movingBlockSet.Position.Z * (float)p.Z;
float num3 = point.X * p.X + point.Y * p.Y + point.Z * p.Z;
if (num2 > num3)
{
if ((float)num + num2 - num3 > 1f)
{
movingBlockSet.SetBlock(p * (num - 1), Terrain.MakeBlockValue(238, 0, PistonHeadBlock.SetFace(PistonHeadBlock.SetIsShaft(PistonHeadBlock.SetMode(0, mode), isShaft: true), face)));
}
}
else if (num2 < num3 && (float)num + num2 - num3 <= 0f)
{
movingBlockSet.SetBlock(p * num, 0);
}
}
}
}
}
public void Update(float dt)
{
if (m_firePointsCopy.Count == 0)
{
m_firePointsCopy.Count += m_fireData.Count;
m_fireData.Keys.CopyTo(m_firePointsCopy.Array, 0);
m_copyIndex = 0;
m_lastScanDuration = (float)(m_subsystemTime.GameTime - m_lastScanTime);
m_lastScanTime = m_subsystemTime.GameTime;
if (m_firePointsCopy.Count == 0)
{
m_fireSoundVolume = 0f;
}
}
if (m_firePointsCopy.Count > 0)
{
float num = MathUtils.Min(1f * dt * (float)m_firePointsCopy.Count + m_remainderToScan, 50f);
int num2 = (int)num;
m_remainderToScan = num - (float)num2;
int num3 = MathUtils.Min(m_copyIndex + num2, m_firePointsCopy.Count);
while (m_copyIndex < num3)
{
if (m_fireData.TryGetValue(m_firePointsCopy.Array[m_copyIndex], out FireData value))
{
int x = value.Point.X;
int y = value.Point.Y;
int z = value.Point.Z;
int num4 = Terrain.ExtractData(base.SubsystemTerrain.Terrain.GetCellValue(x, y, z));
m_fireSoundIntensity += 1f / (m_subsystemAudio.CalculateListenerDistanceSquared(new Vector3(x, y, z)) + 0.01f);
if ((num4 & 1) != 0)
{
value.Time0 -= m_lastScanDuration;
if (value.Time0 <= 0f)
{
QueueBurnAway(x, y, z + 1, value.FireExpandability * 0.85f);
}
foreach (KeyValuePair <Point3, float> expansionProbability in m_expansionProbabilities)
{
if (m_random.Float(0f, 1f) < expansionProbability.Value * m_lastScanDuration * value.FireExpandability)
{
m_toExpand[new Point3(x + expansionProbability.Key.X, y + expansionProbability.Key.Y, z + 1 + expansionProbability.Key.Z)] = value.FireExpandability * 0.85f;
}
}
}
if ((num4 & 2) != 0)
{
value.Time1 -= m_lastScanDuration;
if (value.Time1 <= 0f)
{
QueueBurnAway(x + 1, y, z, value.FireExpandability * 0.85f);
}
foreach (KeyValuePair <Point3, float> expansionProbability2 in m_expansionProbabilities)
{
if (m_random.Float(0f, 1f) < expansionProbability2.Value * m_lastScanDuration * value.FireExpandability)
{
m_toExpand[new Point3(x + 1 + expansionProbability2.Key.X, y + expansionProbability2.Key.Y, z + expansionProbability2.Key.Z)] = value.FireExpandability * 0.85f;
}
}
}
if ((num4 & 4) != 0)
{
value.Time2 -= m_lastScanDuration;
if (value.Time2 <= 0f)
{
QueueBurnAway(x, y, z - 1, value.FireExpandability * 0.85f);
}
foreach (KeyValuePair <Point3, float> expansionProbability3 in m_expansionProbabilities)
{
if (m_random.Float(0f, 1f) < expansionProbability3.Value * m_lastScanDuration * value.FireExpandability)
{
m_toExpand[new Point3(x + expansionProbability3.Key.X, y + expansionProbability3.Key.Y, z - 1 + expansionProbability3.Key.Z)] = value.FireExpandability * 0.85f;
}
}
}
if ((num4 & 8) != 0)
{
value.Time3 -= m_lastScanDuration;
if (value.Time3 <= 0f)
{
QueueBurnAway(x - 1, y, z, value.FireExpandability * 0.85f);
}
foreach (KeyValuePair <Point3, float> expansionProbability4 in m_expansionProbabilities)
{
if (m_random.Float(0f, 1f) < expansionProbability4.Value * m_lastScanDuration * value.FireExpandability)
{
m_toExpand[new Point3(x - 1 + expansionProbability4.Key.X, y + expansionProbability4.Key.Y, z + expansionProbability4.Key.Z)] = value.FireExpandability * 0.85f;
}
}
}
if (num4 == 0)
{
value.Time5 -= m_lastScanDuration;
if (value.Time5 <= 0f)
{
QueueBurnAway(x, y - 1, z, value.FireExpandability * 0.85f);
}
}
}
m_copyIndex++;
}
if (m_copyIndex >= m_firePointsCopy.Count)
{
m_fireSoundVolume = 0.75f * m_fireSoundIntensity;
m_firePointsCopy.Clear();
m_fireSoundIntensity = 0f;
}
}
if (m_subsystemTime.PeriodicGameTimeEvent(5.0, 0.0))
{
int num5 = 0;
int num6 = 0;
foreach (KeyValuePair <Point3, float> item in m_toBurnAway)
{
Point3 key = item.Key;
float value2 = item.Value;
base.SubsystemTerrain.ChangeCell(key.X, key.Y, key.Z, Terrain.ReplaceContents(0, 0));
if (value2 > 0.25f)
{
for (int i = 0; i < 5; i++)
{
Point3 point = CellFace.FaceToPoint3(i);
SetCellOnFire(key.X + point.X, key.Y + point.Y, key.Z + point.Z, value2);
}
}
float num7 = m_subsystemViews.CalculateDistanceFromNearestView(new Vector3(key));
if (num5 < 15 && num7 < 24f)
{
m_subsystemParticles.AddParticleSystem(new BurntDebrisParticleSystem(base.SubsystemTerrain, key.X, key.Y, key.Z));
num5++;
}
if (num6 < 4 && num7 < 16f)
{
m_subsystemAudio.PlayRandomSound("Audio/Sizzles", 1f, m_random.Float(-0.25f, 0.25f), new Vector3(key.X, key.Y, key.Z), 3f, autoDelay: true);
num6++;
}
}
foreach (KeyValuePair <Point3, float> item2 in m_toExpand)
{
SetCellOnFire(item2.Key.X, item2.Key.Y, item2.Key.Z, item2.Value);
}
m_toBurnAway.Clear();
m_toExpand.Clear();
}
m_subsystemAmbientSounds.FireSoundVolume = MathUtils.Max(m_subsystemAmbientSounds.FireSoundVolume, m_fireSoundVolume);
}
public void Update(float dt)
{
Point3 coordinates = m_componentBlockEntity.Coordinates;
if (m_updateSmeltingRecipe)
{
m_updateSmeltingRecipe = false;
result[0] = m_matchedIngredients[7];
result[1] = m_matchedIngredients[8];
result[2] = m_matchedIngredients[9];
bool flag = FindSmeltingRecipe(5f);
if (result[0] != m_matchedIngredients[7] || result[1] != m_matchedIngredients[8] || result[2] != m_matchedIngredients[9])
{
SmeltingProgress = 0f;
m_time = 0;
}
m_smeltingRecipe2 = flag;
if (flag != m_smeltingRecipe)
{
m_smeltingRecipe = flag;
SmeltingProgress = 0f;
m_time = 0;
}
}
if (m_smeltingRecipe2 && Utils.SubsystemTime.PeriodicGameTimeEvent(0.2, 0.0))
{
int num = 1;
int num2 = 0;
var point = CellFace.FaceToPoint3(FourDirectionalBlock.GetDirection(Utils.Terrain.GetCellValue(coordinates.X, coordinates.Y, coordinates.Z)));
int num3 = coordinates.X - point.X;
int num4 = coordinates.Y - point.Y;
int num5 = coordinates.Z - point.Z, v;
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 3; j++)
{
for (int k = -1; k < 2; k++)
{
int cellValue = Terrain.ReplaceLight(Utils.Terrain.GetCellValue(num3 + i, num4 + j, num5 + k), 0);
int cellContents2 = Terrain.ExtractContents(cellValue);
if (j == 1 && cellValue != (MetalBlock.Index | 96 << 14))
{
num = 0;
break;
}
if (i * i + k * k == 1 && j == 0 && cellContents2 == 0 && ((v = Utils.Terrain.GetCellValue(num3 + 2 * i, num4 + j, num5 + 2 * k)) != (BlastBlowerBlock.Index | FurnaceNBlock.SetHeatLevel(Terrain.ExtractData(v), 1) << 14)) && (num3 + i != coordinates.X || num5 + k != coordinates.Z))
{
num = 0;
break;
}
if (i * i + k * k == 1 && j == 0 && cellContents2 == 0)
{
num2++;
}
if (i * i + k * k == 1 && j == 0 && cellContents2 != 0 && cellValue != (MetalBlock.Index | 96 << 14) && (num3 + i != coordinates.X || num5 + k != coordinates.Z))
{
num = 0;
break;
}
if (i * i + k * k == 2 && j == 0 && cellValue != (MetalBlock.Index | 96 << 14))
{
num = 0;
break;
}
if (j < 0 && cellValue != (MetalBlock.Index | 64 << 14))
{
num = 0;
break;
}
}
}
}
if (num == 0 || num2 == 0)
{
m_smeltingRecipe = false;
}
if (num == 1 && num2 >= 2 && !m_smeltingRecipe)
{
m_smeltingRecipe = m_smeltingRecipe2;
}
}
if (!m_smeltingRecipe)
{
HeatLevel = 0f;
m_fireTimeRemaining = 0f;
SmeltingProgress = 0f;
}
if (m_smeltingRecipe && m_fireTimeRemaining <= 0f)
{
HeatLevel = 5f;
}
if (m_smeltingRecipe)
{
SmeltingProgress = MathUtils.Min(SmeltingProgress + 0.1f * dt, 1f);
if (SmeltingProgress >= 1f)
{
int[] array = new int[]
{
IronIngotBlock.Index,
ItemBlock.IdTable["ScrapIron"],
ItemBlock.IdTable["AluminumOrePowder"],
ItemBlock.IdTable["ChromiumOrePowder"],
ItemBlock.IdTable["CokeCoalPowder"]
};
for (int l = 0; l < 5; l++)
{
if (m_matchedIngredients[l] > 0)
{
int b = array[l];
for (int m = 0; m < m_furnaceSize; m++)
{
if (m_slots[m].Count > 0 && GetSlotValue(m) == b)
{
if (m_slots[m].Count >= m_matchedIngredients[l])
{
m_slots[m].Count -= m_matchedIngredients[l];
m_matchedIngredients[l] = 0;
}
else
{
m_matchedIngredients[l] -= m_slots[m].Count;
m_slots[m].Count = 0;
}
if (m_matchedIngredients[l] == 0)
{
break;
}
}
}
}
}
if (m_matchedIngredients[5] >= 1)
{
m_slots[ResultSlotIndex].Value = ItemBlock.IdTable["SteelIngot"];
m_slots[ResultSlotIndex].Count += m_matchedIngredients[5];
}
if (m_matchedIngredients[6] >= 1)
{
m_slots[ResultSlotIndex].Value = IronIngotBlock.Index;
m_slots[ResultSlotIndex].Count += m_matchedIngredients[6];
}
if (m_matchedIngredients[7] >= 1)
{
m_slots[ResultSlotIndex].Value = ItemBlock.IdTable["FeAlCrAlloyIngot"];
m_slots[ResultSlotIndex].Count += m_matchedIngredients[7];
}
m_smeltingRecipe = false;
SmeltingProgress = 0f;
m_updateSmeltingRecipe = true;
}
}
}
public static void GenerateWireVertices(BlockGeometryGenerator generator, int value, int x, int y, int z, int mountingFace, float centerBoxSize, Vector2 centerOffset, TerrainGeometrySubset subset)
{
var terrain = generator.Terrain;
Color color = WireBlock.WireColor;
int num = Terrain.ExtractContents(value);
if (num == ElementBlock.Index)
{
int?color2 = PaintableItemBlock.GetColor(Terrain.ExtractData(value));
if (color2.HasValue)
{
color = SubsystemPalette.GetColor(generator, color2);
}
}
float num3 = LightingManager.LightIntensityByLightValue[Terrain.ExtractLight(value)];
Vector3 v = new Vector3(x + 0.5f, y + 0.5f, z + 0.5f) - 0.5f * CellFace.FaceToVector3(mountingFace);
Vector3 vector = CellFace.FaceToVector3(mountingFace);
var v2 = new Vector2(0.9376f, 0.0001f);
var v3 = new Vector2(0.03125f, 0.00550781237f);
Point3 point = CellFace.FaceToPoint3(mountingFace);
int cellContents = terrain.GetCellContents(x - point.X, y - point.Y, z - point.Z);
bool flag = cellContents == 2 || cellContents == 7 || cellContents == 8 || cellContents == 6 || cellContents == 62 || cellContents == 72;
Vector3 v4 = CellFace.FaceToVector3(SubsystemElectricity.GetConnectorFace(mountingFace, ElectricConnectorDirection.Top));
Vector3 vector2 = CellFace.FaceToVector3(SubsystemElectricity.GetConnectorFace(mountingFace, ElectricConnectorDirection.Left)) * centerOffset.X + v4 * centerOffset.Y;
int num4 = 0;
var paths = new DynamicArray <ElectricConnectionPath>();
ElementBlock.Block.GetAllConnectedNeighbors(terrain, ElementBlock.Block.GetDevice(x, y, z, value), mountingFace, paths);
foreach (ElectricConnectionPath tmpConnectionPath in paths)
{
if ((num4 & (1 << tmpConnectionPath.ConnectorFace)) == 0)
{
ElectricConnectorDirection?connectorDirection = SubsystemElectricity.GetConnectorDirection(mountingFace, 0, tmpConnectionPath.ConnectorFace);
if (centerOffset != Vector2.Zero || connectorDirection != ElectricConnectorDirection.In)
{
num4 |= 1 << tmpConnectionPath.ConnectorFace;
Color color3 = color;
if (num != ElementBlock.Index)
{
int cellValue = terrain.GetCellValue(x + tmpConnectionPath.NeighborOffsetX, y + tmpConnectionPath.NeighborOffsetY, z + tmpConnectionPath.NeighborOffsetZ);
if (Terrain.ExtractContents(cellValue) == ElementBlock.Index)
{
int?color4 = PaintableItemBlock.GetColor(Terrain.ExtractData(cellValue));
if (color4.HasValue)
{
color3 = SubsystemPalette.GetColor(generator, color4);
}
}
}
Vector3 vector3 = (connectorDirection != ElectricConnectorDirection.In) ? CellFace.FaceToVector3(tmpConnectionPath.ConnectorFace) : (-Vector3.Normalize(vector2));
var vector4 = Vector3.Cross(vector, vector3);
float s = (centerBoxSize >= 0f) ? MathUtils.Max(0.03125f, centerBoxSize / 2f) : (centerBoxSize / 2f);
float num5 = (connectorDirection == ElectricConnectorDirection.In) ? 0.03125f : 0.5f;
float num6 = (connectorDirection == ElectricConnectorDirection.In) ? 0f : ((tmpConnectionPath.ConnectorFace == tmpConnectionPath.NeighborFace) ? (num5 + 0.03125f) : ((tmpConnectionPath.ConnectorFace != CellFace.OppositeFace(tmpConnectionPath.NeighborFace)) ? num5 : (num5 - 0.03125f)));
Vector3 vector5 = v - vector4 * 0.03125f + vector3 * s + vector2;
Vector3 vector6 = v - vector4 * 0.03125f + vector3 * num5;
Vector3 vector7 = v + vector4 * 0.03125f + vector3 * num5;
Vector3 vector8 = v + vector4 * 0.03125f + vector3 * s + vector2;
Vector3 vector9 = v + vector * 0.03125f + vector3 * (centerBoxSize / 2f) + vector2;
Vector3 vector10 = v + vector * 0.03125f + vector3 * num6;
if (flag && centerBoxSize == 0f)
{
Vector3 v5 = 0.25f * BlockGeometryGenerator.GetRandomWireOffset(0.5f * (vector5 + vector8), vector);
vector5 += v5;
vector8 += v5;
vector9 += v5;
}
Vector2 vector11 = v2 + v3 * new Vector2(MathUtils.Max(0.0625f, centerBoxSize), 0f);
Vector2 vector12 = v2 + v3 * new Vector2(num5 * 2f, 0f);
Vector2 vector13 = v2 + v3 * new Vector2(num5 * 2f, 1f);
Vector2 vector14 = v2 + v3 * new Vector2(MathUtils.Max(0.0625f, centerBoxSize), 1f);
Vector2 vector15 = v2 + v3 * new Vector2(centerBoxSize, 0.5f);
Vector2 vector16 = v2 + v3 * new Vector2(num6 * 2f, 0.5f);
float num9 = 0.5f * (num3 + LightingManager.LightIntensityByLightValue[Terrain.ExtractLight(terrain.GetCellValue(x + tmpConnectionPath.NeighborOffsetX, y + tmpConnectionPath.NeighborOffsetY, z + tmpConnectionPath.NeighborOffsetZ))]);
float num10 = LightingManager.CalculateLighting(-vector4);
float num11 = LightingManager.CalculateLighting(vector4);
float num12 = LightingManager.CalculateLighting(vector);
float num13 = num10 * num3;
float num14 = num10 * num9;
float num15 = num11 * num9;
float num16 = num11 * num3;
float num17 = num12 * num3;
float num18 = num12 * num9;
var color5 = new Color((byte)(color3.R * num13), (byte)(color3.G * num13), (byte)(color3.B * num13));
var color6 = new Color((byte)(color3.R * num14), (byte)(color3.G * num14), (byte)(color3.B * num14));
var color7 = new Color((byte)(color3.R * num15), (byte)(color3.G * num15), (byte)(color3.B * num15));
var color8 = new Color((byte)(color3.R * num16), (byte)(color3.G * num16), (byte)(color3.B * num16));
var color9 = new Color((byte)(color3.R * num17), (byte)(color3.G * num17), (byte)(color3.B * num17));
var color10 = new Color((byte)(color3.R * num18), (byte)(color3.G * num18), (byte)(color3.B * num18));
int count = subset.Vertices.Count;
subset.Vertices.Count += 6;
TerrainVertex[] array = subset.Vertices.Array;
BlockGeometryGenerator.SetupVertex(vector5.X, vector5.Y, vector5.Z, color5, vector11.X, vector11.Y, ref array[count]);
BlockGeometryGenerator.SetupVertex(vector6.X, vector6.Y, vector6.Z, color6, vector12.X, vector12.Y, ref array[count + 1]);
BlockGeometryGenerator.SetupVertex(vector7.X, vector7.Y, vector7.Z, color7, vector13.X, vector13.Y, ref array[count + 2]);
BlockGeometryGenerator.SetupVertex(vector8.X, vector8.Y, vector8.Z, color8, vector14.X, vector14.Y, ref array[count + 3]);
BlockGeometryGenerator.SetupVertex(vector9.X, vector9.Y, vector9.Z, color9, vector15.X, vector15.Y, ref array[count + 4]);
BlockGeometryGenerator.SetupVertex(vector10.X, vector10.Y, vector10.Z, color10, vector16.X, vector16.Y, ref array[count + 5]);
int count2 = subset.Indices.Count;
subset.Indices.Count += (connectorDirection == ElectricConnectorDirection.In) ? 15 : 12;
ushort[] array2 = subset.Indices.Array;
array2[count2] = (ushort)count;
array2[count2 + 1] = (ushort)(count + 5);
array2[count2 + 2] = (ushort)(count + 1);
array2[count2 + 3] = (ushort)(count + 5);
array2[count2 + 4] = (ushort)count;
array2[count2 + 5] = (ushort)(count + 4);
array2[count2 + 6] = (ushort)(count + 4);
array2[count2 + 7] = (ushort)(count + 2);
array2[count2 + 8] = (ushort)(count + 5);
array2[count2 + 9] = (ushort)(count + 2);
array2[count2 + 10] = (ushort)(count + 4);
array2[count2 + 11] = (ushort)(count + 3);
if (connectorDirection == ElectricConnectorDirection.In)
{
array2[count2 + 12] = (ushort)(count + 2);
array2[count2 + 13] = (ushort)(count + 1);
array2[count2 + 14] = (ushort)(count + 5);
}
}
}
}
if (centerBoxSize == 0f && (num4 != 0 || (num == ElementBlock.Index && (Terrain.ExtractData(value) & 1023) == 5)))
{
for (int i = 0; i < 6; i++)
{
if (i != mountingFace && i != CellFace.OppositeFace(mountingFace) && (num4 & (1 << i)) == 0)
{
Vector3 vector17 = CellFace.FaceToVector3(i);
var v6 = Vector3.Cross(vector, vector17);
Vector3 vector18 = v - v6 * 0.03125f + vector17 * 0.03125f;
Vector3 vector19 = v + v6 * 0.03125f + vector17 * 0.03125f;
Vector3 vector20 = v + vector * 0.03125f;
if (flag)
{
Vector3 v7 = 0.25f * BlockGeometryGenerator.GetRandomWireOffset(0.5f * (vector18 + vector19), vector);
vector18 += v7;
vector19 += v7;
vector20 += v7;
}
Vector2 vector21 = v2 + v3 * new Vector2(0.0625f, 0f);
Vector2 vector22 = v2 + v3 * new Vector2(0.0625f, 1f);
Vector2 vector23 = v2 + v3 * new Vector2(0f, 0.5f);
float num19 = LightingManager.CalculateLighting(vector17) * num3;
float num20 = LightingManager.CalculateLighting(vector) * num3;
var color11 = new Color((byte)(color.R * num19), (byte)(color.G * num19), (byte)(color.B * num19));
var color12 = new Color((byte)(color.R * num20), (byte)(color.G * num20), (byte)(color.B * num20));
int count3 = subset.Vertices.Count;
subset.Vertices.Count += 3;
var array3 = subset.Vertices.Array;
BlockGeometryGenerator.SetupVertex(vector18.X, vector18.Y, vector18.Z, color11, vector21.X, vector21.Y, ref array3[count3]);
BlockGeometryGenerator.SetupVertex(vector19.X, vector19.Y, vector19.Z, color11, vector22.X, vector22.Y, ref array3[count3 + 1]);
BlockGeometryGenerator.SetupVertex(vector20.X, vector20.Y, vector20.Z, color12, vector23.X, vector23.Y, ref array3[count3 + 2]);
int count4 = subset.Indices.Count;
subset.Indices.Count += 3;
ushort[] array4 = subset.Indices.Array;
array4[count4] = (ushort)count3;
array4[count4 + 1] = (ushort)(count3 + 2);
array4[count4 + 2] = (ushort)(count3 + 1);
}
}
}
}
public bool Place(TerrainRaycastResult raycastResult, int value)
{
if (Place2 != null)
{
return(Place2(raycastResult, value));
}
int num = Terrain.ExtractContents(value);
if (BlocksManager.Blocks[num].IsPlaceable)
{
Block block = BlocksManager.Blocks[num];
BlockPlacementData placementData = block.GetPlacementValue(m_subsystemTerrain, this, value, raycastResult);
if (placementData.Value != 0)
{
Point3 point = CellFace.FaceToPoint3(placementData.CellFace.Face);
int num2 = placementData.CellFace.X + point.X;
int num3 = placementData.CellFace.Y + point.Y;
int num4 = placementData.CellFace.Z + point.Z;
if (num3 > 0 && num3 < 255 && (IsBlockPlacingAllowed(ComponentCreature.ComponentBody) || m_subsystemGameInfo.WorldSettings.GameMode <= GameMode.Harmless))
{
bool flag = false;
if (block.IsCollidable)
{
BoundingBox boundingBox = ComponentCreature.ComponentBody.BoundingBox;
boundingBox.Min += new Vector3(0.2f);
boundingBox.Max -= new Vector3(0.2f);
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(m_subsystemTerrain, placementData.Value);
for (int i = 0; i < customCollisionBoxes.Length; i++)
{
BoundingBox box = customCollisionBoxes[i];
box.Min += new Vector3(num2, num3, num4);
box.Max += new Vector3(num2, num3, num4);
if (boundingBox.Intersection(box))
{
flag = true;
break;
}
}
}
if (!flag)
{
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(Terrain.ExtractContents(placementData.Value));
for (int i = 0; i < blockBehaviors.Length; i++)
{
blockBehaviors[i].OnItemPlaced(num2, num3, num4, ref placementData, value);
}
m_subsystemTerrain.DestroyCell(0, num2, num3, num4, placementData.Value, noDrop: false, noParticleSystem: false);
m_subsystemAudio.PlaySound("Audio/BlockPlaced", 1f, 0f, new Vector3(placementData.CellFace.X, placementData.CellFace.Y, placementData.CellFace.Z), 5f, autoDelay: false);
Poke(forceRestart: false);
if (ComponentCreature.PlayerStats != null)
{
ComponentCreature.PlayerStats.BlocksPlaced++;
}
return(true);
}
}
}
}
return(false);
}
public override BlockPlacementData GetPlacementValue(SubsystemTerrain subsystemTerrain, ComponentMiner componentMiner, int value, TerrainRaycastResult raycastResult)
{
Vector3 forward = Matrix.CreateFromQuaternion(componentMiner.ComponentCreature.ComponentCreatureModel.EyeRotation).Forward;
float num = Vector3.Dot(forward, Vector3.UnitZ);
float num2 = Vector3.Dot(forward, Vector3.UnitX);
float num3 = Vector3.Dot(forward, -Vector3.UnitZ);
float num4 = Vector3.Dot(forward, -Vector3.UnitX);
int num5 = 0;
if (num == MathUtils.Max(num, num2, num3, num4))
{
num5 = 2;
}
else if (num2 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 3;
}
else if (num3 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 0;
}
else if (num4 == MathUtils.Max(num, num2, num3, num4))
{
num5 = 1;
}
Point3 point = CellFace.FaceToPoint3(raycastResult.CellFace.Face);
int num6 = raycastResult.CellFace.X + point.X;
int y = raycastResult.CellFace.Y + point.Y;
int num7 = raycastResult.CellFace.Z + point.Z;
int num8 = 0;
int num9 = 0;
switch (num5)
{
case 0:
num8 = -1;
break;
case 1:
num9 = 1;
break;
case 2:
num8 = 1;
break;
default:
num9 = -1;
break;
}
int cellValue = subsystemTerrain.Terrain.GetCellValue(num6 + num8, y, num7 + num9);
int cellValue2 = subsystemTerrain.Terrain.GetCellValue(num6 - num8, y, num7 - num9);
Block block = BlocksManager.Blocks[Terrain.ExtractContents(cellValue)];
Block block2 = BlocksManager.Blocks[Terrain.ExtractContents(cellValue2)];
int data = Terrain.ExtractData(cellValue);
int data2 = Terrain.ExtractData(cellValue2);
bool flag = false;
int data3 = SetRightHanded(rightHanded: (block is FenceGateBlock && GetRotation(data) == num5) || ((!(block2 is FenceGateBlock) || GetRotation(data2) != num5) && !block.IsCollidable), data: SetOpen(SetRotation(Terrain.ExtractData(value), num5), open: false));
BlockPlacementData result = default(BlockPlacementData);
result.Value = Terrain.ReplaceData(Terrain.ReplaceContents(0, BlockIndex), data3);
result.CellFace = raycastResult.CellFace;
return(result);
}
public static Point3 RotationToDirection(int rotation)
{
return(CellFace.FaceToPoint3((rotation + 2) % 4));
}
public bool MovePiston(Point3 position, int length)
{
Terrain terrain = m_subsystemTerrain.Terrain;
int data = Terrain.ExtractData(terrain.GetCellValue(position.X, position.Y, position.Z));
int face = PistonBlock.GetFace(data);
PistonMode mode = PistonBlock.GetMode(data);
int maxExtension = PistonBlock.GetMaxExtension(data);
int pullCount = PistonBlock.GetPullCount(data);
int speed = PistonBlock.GetSpeed(data);
Point3 point = CellFace.FaceToPoint3(face);
length = MathUtils.Clamp(length, 0, maxExtension + 1);
int num = 0;
m_movingBlocks.Clear();
Point3 offset = point;
MovingBlock item;
while (m_movingBlocks.Count < 8)
{
int cellValue = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
int num2 = Terrain.ExtractContents(cellValue);
int face2 = PistonHeadBlock.GetFace(Terrain.ExtractData(cellValue));
if (num2 != 238 || face2 != face)
{
break;
}
DynamicArray <MovingBlock> movingBlocks = m_movingBlocks;
item = new MovingBlock
{
Offset = offset,
Value = cellValue
};
movingBlocks.Add(item);
offset += point;
num++;
}
if (length > num)
{
DynamicArray <MovingBlock> movingBlocks2 = m_movingBlocks;
item = new MovingBlock
{
Offset = Point3.Zero,
Value = Terrain.MakeBlockValue(238, 0, PistonHeadBlock.SetFace(PistonHeadBlock.SetMode(PistonHeadBlock.SetIsShaft(0, num > 0), mode), face))
};
movingBlocks2.Add(item);
int num3 = 0;
while (num3 < 8)
{
int cellValue2 = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
if (!IsBlockMovable(cellValue2, face, position.Y + offset.Y, out bool isEnd))
{
break;
}
DynamicArray <MovingBlock> movingBlocks3 = m_movingBlocks;
item = new MovingBlock
{
Offset = offset,
Value = cellValue2
};
movingBlocks3.Add(item);
num3++;
offset += point;
if (isEnd)
{
break;
}
}
if (!IsBlockBlocking(terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z)))
{
GetSpeedAndSmoothness(speed, out float speed2, out Vector2 smoothness);
Point3 p = position + (length - num) * point;
if (m_subsystemMovingBlocks.AddMovingBlockSet(new Vector3(position) + 0.01f * new Vector3(point), new Vector3(p), speed2, 0f, 0f, smoothness, m_movingBlocks, "Piston", position, testCollision: true) != null)
{
m_allowPistonHeadRemove = true;
try
{
foreach (MovingBlock movingBlock in m_movingBlocks)
{
if (movingBlock.Offset != Point3.Zero)
{
m_subsystemTerrain.ChangeCell(position.X + movingBlock.Offset.X, position.Y + movingBlock.Offset.Y, position.Z + movingBlock.Offset.Z, 0);
}
}
}
finally
{
m_allowPistonHeadRemove = false;
}
m_subsystemTerrain.ChangeCell(position.X, position.Y, position.Z, Terrain.MakeBlockValue(237, 0, PistonBlock.SetIsExtended(data, isExtended: true)));
m_subsystemAudio.PlaySound("Audio/Piston", 1f, 0f, new Vector3(position), 2f, autoDelay: true);
}
}
return(false);
}
if (length < num)
{
if (mode != 0)
{
int num4 = 0;
for (int i = 0; i < pullCount + 1; i++)
{
int cellValue3 = terrain.GetCellValue(position.X + offset.X, position.Y + offset.Y, position.Z + offset.Z);
if (!IsBlockMovable(cellValue3, face, position.Y + offset.Y, out bool isEnd2))
{
break;
}
DynamicArray <MovingBlock> movingBlocks4 = m_movingBlocks;
item = new MovingBlock
{
Offset = offset,
Value = cellValue3
};
movingBlocks4.Add(item);
offset += point;
num4++;
if (isEnd2)
{
break;
}
}
if (mode == PistonMode.StrictPulling && num4 < pullCount + 1)
{
return(false);
}
}
GetSpeedAndSmoothness(speed, out float speed3, out Vector2 smoothness2);
float s = (length == 0) ? 0.01f : 0f;
Vector3 targetPosition = new Vector3(position) + (length - num) * new Vector3(point) + s * new Vector3(point);
if (m_subsystemMovingBlocks.AddMovingBlockSet(new Vector3(position), targetPosition, speed3, 0f, 0f, smoothness2, m_movingBlocks, "Piston", position, testCollision: true) != null)
{
m_allowPistonHeadRemove = true;
try
{
foreach (MovingBlock movingBlock2 in m_movingBlocks)
{
m_subsystemTerrain.ChangeCell(position.X + movingBlock2.Offset.X, position.Y + movingBlock2.Offset.Y, position.Z + movingBlock2.Offset.Z, 0);
}
}
finally
{
m_allowPistonHeadRemove = false;
}
m_subsystemAudio.PlaySound("Audio/Piston", 1f, 0f, new Vector3(position), 2f, autoDelay: true);
}
return(false);
}
return(true);
}
