public void SimulateElectricElement(ElectricElement electricElement)
{
if (electricElement.Simulate())
{
QueueElectricElementConnectionsForSimulation(electricElement, CircuitStep + 1);
}
}
public void UpdateElectricElements()
{
foreach (KeyValuePair <Point3, bool> item in m_pointsToUpdate)
{
Point3 key = item.Key;
int cellValue = SubsystemTerrain.Terrain.GetCellValue(key.X, key.Y, key.Z);
for (int i = 0; i < 6; i++)
{
ElectricElement electricElement = GetElectricElement(key.X, key.Y, key.Z, i);
if (electricElement != null)
{
if (electricElement is WireDomainElectricElement)
{
m_wiresToUpdate[key] = true;
}
else
{
m_electricElementsToRemove[electricElement] = true;
}
}
}
if (item.Value)
{
m_persistentElementsVoltages.Remove(key);
}
int num = Terrain.ExtractContents(cellValue);
if (BlocksManager.Blocks[num] is IElectricWireElementBlock)
{
m_wiresToUpdate[key] = true;
}
else
{
IElectricElementBlock electricElementBlock = BlocksManager.Blocks[num] as IElectricElementBlock;
if (electricElementBlock != null)
{
ElectricElement electricElement2 = electricElementBlock.CreateElectricElement(this, cellValue, key.X, key.Y, key.Z);
if (electricElement2 != null)
{
m_electricElementsToAdd[key] = electricElement2;
}
}
}
}
RemoveWireDomains();
foreach (KeyValuePair <ElectricElement, bool> item2 in m_electricElementsToRemove)
{
RemoveElectricElement(item2.Key);
}
AddWireDomains();
foreach (ElectricElement value in m_electricElementsToAdd.Values)
{
AddElectricElement(value);
}
m_pointsToUpdate.Clear();
m_wiresToUpdate.Clear();
m_electricElementsToAdd.Clear();
m_electricElementsToRemove.Clear();
}
public void QueueElectricElementConnectionsForSimulation(ElectricElement electricElement, int circuitStep)
{
foreach (ElectricConnection connection in electricElement.Connections)
{
if (connection.ConnectorType != 0 && connection.NeighborConnectorType != ElectricConnectorType.Output)
{
QueueElectricElementForSimulation(connection.NeighborElectricElement, circuitStep);
}
}
}
public void Press()
{
if (!m_wasPressed && !ElectricElement.IsSignalHigh(m_voltage))
{
m_wasPressed = true;
CellFace cellFace = base.CellFaces[0];
base.SubsystemElectricity.SubsystemAudio.PlaySound("Audio/Click", 1f, 0f, new Vector3(cellFace.X, cellFace.Y, cellFace.Z), 2f, autoDelay: true);
base.SubsystemElectricity.QueueElectricElementForSimulation(this, base.SubsystemElectricity.CircuitStep + 1);
}
}
public override bool OnInteract(TerrainRaycastResult raycastResult, ComponentMiner componentMiner)
{
int x = raycastResult.CellFace.X;
int y = raycastResult.CellFace.Y;
int z = raycastResult.CellFace.Z;
for (int i = 0; i < 6; i++)
{
ElectricElement electricElement = m_subsystemElectricity.GetElectricElement(x, y, z, i);
if (electricElement != null)
{
return(electricElement.OnInteract(raycastResult, componentMiner));
}
}
return(false);
}
public bool IsTrapdoorElectricallyConnected(int x, int y, int z)
{
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x, y, z);
int num = Terrain.ExtractContents(cellValue);
int data = Terrain.ExtractData(cellValue);
if (BlocksManager.Blocks[num] is TrapdoorBlock)
{
ElectricElement electricElement = m_subsystemElectricity.GetElectricElement(x, y, z, TrapdoorBlock.GetMountingFace(data));
if (electricElement != null && electricElement.Connections.Count > 0)
{
return(true);
}
}
return(false);
}
public override bool OnEditBlock(int x, int y, int z, int value, ComponentPlayer componentPlayer)
{
MemoryBankData memoryBankData = GetBlockData(new Point3(x, y, z)) ?? new MemoryBankData();
DialogsManager.ShowDialog(componentPlayer.GuiWidget, new EditMemeryDialogB(memoryBankData, delegate() {
SetBlockData(new Point3(x, y, z), memoryBankData);
int face = ((MemoryBankBlock)BlocksManager.Blocks[186]).GetFace(value);
SubsystemElectricity subsystemElectricity = base.SubsystemTerrain.Project.FindSubsystem <SubsystemElectricity>(throwOnError: true);
ElectricElement electricElement = subsystemElectricity.GetElectricElement(x, y, z, face);
if (electricElement != null)
{
subsystemElectricity.QueueElectricElementForSimulation(electricElement, subsystemElectricity.CircuitStep + 1);
}
}));
return(true);
}
public void AddElectricElement(ElectricElement electricElement)
{
m_electricElements.Add(electricElement, value: true);
foreach (CellFace cellFace2 in electricElement.CellFaces)
{
m_electricElementsByCellFace.Add(cellFace2, electricElement);
m_tmpConnectionPaths.Clear();
GetAllConnectedNeighbors(cellFace2.X, cellFace2.Y, cellFace2.Z, cellFace2.Face, m_tmpConnectionPaths);
foreach (ElectricConnectionPath tmpConnectionPath in m_tmpConnectionPaths)
{
CellFace cellFace = new CellFace(cellFace2.X + tmpConnectionPath.NeighborOffsetX, cellFace2.Y + tmpConnectionPath.NeighborOffsetY, cellFace2.Z + tmpConnectionPath.NeighborOffsetZ, tmpConnectionPath.NeighborFace);
if (m_electricElementsByCellFace.TryGetValue(cellFace, out ElectricElement value) && value != electricElement)
{
int cellValue = SubsystemTerrain.Terrain.GetCellValue(cellFace2.X, cellFace2.Y, cellFace2.Z);
int num = Terrain.ExtractContents(cellValue);
ElectricConnectorType value2 = ((IElectricElementBlock)BlocksManager.Blocks[num]).GetConnectorType(SubsystemTerrain, cellValue, cellFace2.Face, tmpConnectionPath.ConnectorFace, cellFace2.X, cellFace2.Y, cellFace2.Z).Value;
int cellValue2 = SubsystemTerrain.Terrain.GetCellValue(cellFace.X, cellFace.Y, cellFace.Z);
int num2 = Terrain.ExtractContents(cellValue2);
ElectricConnectorType value3 = ((IElectricElementBlock)BlocksManager.Blocks[num2]).GetConnectorType(SubsystemTerrain, cellValue2, cellFace.Face, tmpConnectionPath.NeighborConnectorFace, cellFace.X, cellFace.Y, cellFace.Z).Value;
electricElement.Connections.Add(new ElectricConnection
{
CellFace = cellFace2,
ConnectorFace = tmpConnectionPath.ConnectorFace,
ConnectorType = value2,
NeighborElectricElement = value,
NeighborCellFace = cellFace,
NeighborConnectorFace = tmpConnectionPath.NeighborConnectorFace,
NeighborConnectorType = value3
});
value.Connections.Add(new ElectricConnection
{
CellFace = cellFace,
ConnectorFace = tmpConnectionPath.NeighborConnectorFace,
ConnectorType = value3,
NeighborElectricElement = electricElement,
NeighborCellFace = cellFace2,
NeighborConnectorFace = tmpConnectionPath.ConnectorFace,
NeighborConnectorType = value2
});
}
}
}
QueueElectricElementForSimulation(electricElement, CircuitStep + 1);
QueueElectricElementConnectionsForSimulation(electricElement, CircuitStep + 2);
electricElement.OnAdded();
}
public override bool Simulate()
{
float voltage = m_voltage;
bool flag = false;
bool flag2 = false;
_ = base.Rotation;
foreach (ElectricConnection connection in base.Connections)
{
if (connection.ConnectorType != ElectricConnectorType.Output && connection.NeighborConnectorType != 0)
{
if (ElectricElement.IsSignalHigh(connection.NeighborElectricElement.GetOutputVoltage(connection.NeighborConnectorFace)))
{
if (m_clockAllowed)
{
flag = true;
m_clockAllowed = false;
}
}
else
{
m_clockAllowed = true;
}
flag2 = true;
}
}
if (flag2)
{
if (flag)
{
m_voltage = GetRandomVoltage();
}
}
else
{
m_voltage = GetRandomVoltage();
base.SubsystemElectricity.QueueElectricElementForSimulation(this, base.SubsystemElectricity.CircuitStep + MathUtils.Max((int)(s_random.Float(0.25f, 0.75f) / 0.01f), 1));
}
if (m_voltage != voltage)
{
base.SubsystemElectricity.WritePersistentVoltage(base.CellFaces[0].Point, m_voltage);
return(true);
}
return(false);
}
public void RemoveElectricElement(ElectricElement electricElement)
{
electricElement.OnRemoved();
QueueElectricElementConnectionsForSimulation(electricElement, CircuitStep + 1);
m_electricElements.Remove(electricElement);
foreach (CellFace cellFace in electricElement.CellFaces)
{
m_electricElementsByCellFace.Remove(cellFace);
}
foreach (ElectricConnection connection in electricElement.Connections)
{
int num = connection.NeighborElectricElement.Connections.FirstIndex((ElectricConnection c) => c.NeighborElectricElement == electricElement);
if (num >= 0)
{
connection.NeighborElectricElement.Connections.RemoveAt(num);
}
}
}
public override bool Simulate()
{
float voltage = m_voltage;
m_voltage = CalculateVoltage();
if (ElectricElement.IsSignalHigh(m_voltage) != ElectricElement.IsSignalHigh(voltage))
{
if (ElectricElement.IsSignalHigh(m_voltage))
{
m_glowPoint.Color = m_color;
}
else
{
m_glowPoint.Color = Color.Transparent;
}
}
return(false);
}
public bool IsDoorElectricallyConnected(int x, int y, int z)
{
int cellValue = base.SubsystemTerrain.Terrain.GetCellValue(x, y, z);
int num = Terrain.ExtractContents(cellValue);
int data = Terrain.ExtractData(cellValue);
if (BlocksManager.Blocks[num] is DoorBlock)
{
int num2 = DoorBlock.IsBottomPart(base.SubsystemTerrain.Terrain, x, y, z) ? y : (y - 1);
for (int i = num2; i <= num2 + 1; i++)
{
ElectricElement electricElement = m_subsystemElectricity.GetElectricElement(x, i, z, DoorBlock.GetHingeFace(data));
if (electricElement != null && electricElement.Connections.Count > 0)
{
return(true);
}
}
}
return(false);
}
public void QueueElectricElementForSimulation(ElectricElement electricElement, int circuitStep)
{
if (circuitStep == CircuitStep + 1)
{
if (m_nextStepSimulateList == null && !m_futureSimulateLists.TryGetValue(CircuitStep + 1, out m_nextStepSimulateList))
{
m_nextStepSimulateList = GetListFromCache();
m_futureSimulateLists.Add(CircuitStep + 1, m_nextStepSimulateList);
}
m_nextStepSimulateList[electricElement] = true;
}
else if (circuitStep > CircuitStep + 1)
{
if (!m_futureSimulateLists.TryGetValue(circuitStep, out Dictionary <ElectricElement, bool> value))
{
value = GetListFromCache();
m_futureSimulateLists.Add(circuitStep, value);
}
value[electricElement] = true;
}
}
public override void OnHitByProjectile(CellFace cellFace, WorldItem worldItem)
{
if (m_score == 0 && !ElectricElement.IsSignalHigh(m_voltage))
{
if (cellFace.Face == 0 || cellFace.Face == 2)
{
float num = worldItem.Position.X - (float)cellFace.X - 0.5f;
float num2 = worldItem.Position.Y - (float)cellFace.Y - 0.5f;
float num3 = MathUtils.Sqrt(num * num + num2 * num2);
m_score = MathUtils.Clamp((int)MathUtils.Round(8f * (1f - num3 / 0.707f)), 1, 8);
}
else
{
float num4 = worldItem.Position.Z - (float)cellFace.Z - 0.5f;
float num5 = worldItem.Position.Y - (float)cellFace.Y - 0.5f;
float num6 = MathUtils.Sqrt(num4 * num4 + num5 * num5);
m_score = MathUtils.Clamp((int)MathUtils.Round(8f * (1f - num6 / 0.5f)), 1, 8);
}
base.SubsystemElectricity.QueueElectricElementForSimulation(this, base.SubsystemElectricity.CircuitStep + 1);
}
}
public override bool Simulate()
{
float voltage = m_voltage;
if (m_pressure > 0f && Time.FrameIndex - m_lastPressFrameIndex < 2)
{
m_voltage = PressureToVoltage(m_pressure);
base.SubsystemElectricity.QueueElectricElementForSimulation(this, base.SubsystemElectricity.CircuitStep + 10);
}
else
{
if (ElectricElement.IsSignalHigh(m_voltage))
{
CellFace cellFace = base.CellFaces[0];
base.SubsystemElectricity.SubsystemAudio.PlaySound("Audio/BlockPlaced", 0.6f, -0.1f, new Vector3(cellFace.X, cellFace.Y, cellFace.Z), 2.5f, autoDelay: true);
}
m_voltage = 0f;
m_pressure = 0f;
}
return(m_voltage != voltage);
}
public override bool OnEditBlock(int x, int y, int z, int value, ComponentPlayer componentPlayer)
{
int contents = Terrain.ExtractContents(value);
int data = Terrain.ExtractData(value);
DialogsManager.ShowDialog(componentPlayer.GuiWidget, new EditPistonDialog(data, delegate(int newData)
{
if (newData != data && base.SubsystemTerrain.Terrain.GetCellContents(x, y, z) == contents)
{
int value2 = Terrain.ReplaceData(value, newData);
base.SubsystemTerrain.ChangeCell(x, y, z, value2);
SubsystemElectricity subsystemElectricity = base.Project.FindSubsystem <SubsystemElectricity>(throwOnError: true);
ElectricElement electricElement = subsystemElectricity.GetElectricElement(x, y, z, 0);
if (electricElement != null)
{
subsystemElectricity.QueueElectricElementForSimulation(electricElement, subsystemElectricity.CircuitStep + 1);
}
}
}));
return(true);
}
public override bool Simulate()
{
int counter = m_counter;
bool overflow = m_overflow;
bool flag = false;
bool flag2 = false;
bool flag3 = false;
int rotation = base.Rotation;
foreach (ElectricConnection connection in base.Connections)
{
if (connection.ConnectorType != ElectricConnectorType.Output && connection.NeighborConnectorType != 0)
{
ElectricConnectorDirection?connectorDirection = SubsystemElectricity.GetConnectorDirection(base.CellFaces[0].Face, rotation, connection.ConnectorFace);
if (connectorDirection.HasValue)
{
if (connectorDirection == ElectricConnectorDirection.Right)
{
flag = ElectricElement.IsSignalHigh(connection.NeighborElectricElement.GetOutputVoltage(connection.NeighborConnectorFace));
}
else if (connectorDirection == ElectricConnectorDirection.Left)
{
flag2 = ElectricElement.IsSignalHigh(connection.NeighborElectricElement.GetOutputVoltage(connection.NeighborConnectorFace));
}
else if (connectorDirection == ElectricConnectorDirection.In)
{
flag3 = ElectricElement.IsSignalHigh(connection.NeighborElectricElement.GetOutputVoltage(connection.NeighborConnectorFace));
}
}
}
}
if (flag && m_plusAllowed)
{
m_plusAllowed = false;
if (m_counter < 15)
{
m_counter++;
m_overflow = false;
}
else
{
m_counter = 0;
m_overflow = true;
}
}
else if (flag2 && m_minusAllowed)
{
m_minusAllowed = false;
if (m_counter > 0)
{
m_counter--;
m_overflow = false;
}
else
{
m_counter = 15;
m_overflow = true;
}
}
else if (flag3 && m_resetAllowed)
{
m_counter = 0;
m_overflow = false;
}
if (!flag)
{
m_plusAllowed = true;
}
if (!flag2)
{
m_minusAllowed = true;
}
if (!flag3)
{
m_resetAllowed = true;
}
if (m_counter != counter || m_overflow != overflow)
{
base.SubsystemElectricity.WritePersistentVoltage(base.CellFaces[0].Point, (float)m_counter / 15f * (float)((!m_overflow) ? 1 : (-1)));
return(true);
}
return(false);
}
public override bool Simulate()
{
float voltage = m_voltage;
m_voltage = 0f;
int rotation = base.Rotation;
foreach (ElectricConnection connection in base.Connections)
{
if (connection.ConnectorType != ElectricConnectorType.Output && connection.NeighborConnectorType != 0 && ElectricElement.IsSignalHigh(connection.NeighborElectricElement.GetOutputVoltage(connection.NeighborConnectorFace)))
{
ElectricConnectorDirection?connectorDirection = SubsystemElectricity.GetConnectorDirection(base.CellFaces[0].Face, rotation, connection.ConnectorFace);
if (connectorDirection.HasValue)
{
if (connectorDirection.Value == ElectricConnectorDirection.Top)
{
m_voltage += 71f / (339f * (float)Math.PI);
}
if (connectorDirection.Value == ElectricConnectorDirection.Right)
{
m_voltage += 142f / (339f * (float)Math.PI);
}
if (connectorDirection.Value == ElectricConnectorDirection.Bottom)
{
m_voltage += 4f / 15f;
}
if (connectorDirection.Value == ElectricConnectorDirection.Left)
{
m_voltage += 8f / 15f;
}
}
}
}
return(m_voltage != voltage);
}
