public static ElectricalCableTile RetrieveElectricalTile(Connection WireEndA, Connection WireEndB, PowerTypeCategory powerTypeCategory)
{
ElectricalCableTile Tile = null;
int spriteIndex = WireDirections.GetSpriteIndex(WireEndA, WireEndB);
switch (powerTypeCategory)
{
case PowerTypeCategory.StandardCable:
{
Tile = ElectricalManager.Instance.MediumVoltageCables.Tiles[spriteIndex];
break;
}
case PowerTypeCategory.LowVoltageCable:
{
Tile = ElectricalManager.Instance.LowVoltageCables.Tiles[spriteIndex];
break;
}
case PowerTypeCategory.HighVoltageCable:
{
Tile = ElectricalManager.Instance.HighVoltageCables.Tiles[spriteIndex];
break;
}
}
return(Tile);
}
public void SetUp(ElectricalCableTile electricalCableTile)
{
Categorytype = electricalCableTile.PowerType;
CanConnectTo = new HashSet <PowerTypeCategory>(electricalCableTile.CanConnectTo);
WireEndB = electricalCableTile.WireEndB;
WireEndA = electricalCableTile.WireEndA;
}
public static ElectricalCableTile RetrieveElectricalTile(Connection WireEndA, Connection WireEndB, PowerTypeCategory powerTypeCategory)
{
ElectricalCableTile Tile = null;
string Compound;
if (WireEndA < WireEndB)
{
Compound = WireEndA + "_" + WireEndB;
}
else
{
Compound = WireEndB + "_" + WireEndA;
}
int spriteIndex = WireDirections.GetSpriteIndex(Compound);
switch (powerTypeCategory)
{
case PowerTypeCategory.StandardCable:
Tile = ElectricalManager.Instance.MediumVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.LowVoltageCable:
Tile = ElectricalManager.Instance.LowVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.HighVoltageCable:
Tile = ElectricalManager.Instance.HighVoltageCables.Tiles[spriteIndex];
break;
}
return(Tile);
}
/// <summary>
/// <para>Replaces, builds a new electrical connection, and consumes
/// cables from the hand.</para>
/// <para>Destroys the electrical connection (if we're given one) and
/// then adds a new electrical connection by adding an electrical
/// node. We then calculate and consume a number of cables from the
/// hand.</para>
/// </summary>
/// <param name="position">Position of the electrical connection.</param>
/// <param name="eConn">Electrical connection we're replacing.</param>
/// <param name="wireEndA">Connection direction of one end.</param>
/// <param name="wireEndB">Connection direction of the other end.</param>
private void ReplaceEConn(Vector3 position, IntrinsicElectronicData eConn, Connection wireEndA,
Connection wireEndB, ConnectionApply interaction)
{
// Cost of cable coils to construct the original cable tile. Assume
// 0 until we verify whether or not we are given an electrical
// connection.
int oldTileCost = 0;
// Get the cost of the old tile. Then destroy the current
// electrical connection only if we were given a connection.
if (eConn != null)
{
oldTileCost = eConn.MetaDataPresent.RelatedTile.SpawnAmountOnDeconstruct;
eConn.DestroyThisPlease();
}
// Get the electrical cable tile with the wire connection direction.
ElectricalCableTile tile =
ElectricityFunctions.RetrieveElectricalTile(wireEndA, wireEndB, powerTypeCategory);
// Then, add an electrical node at the tile.
interaction.Performer.GetComponentInParent <Matrix>().AddElectricalNode(position.RoundToInt(), tile, true);
// We only want to consume the difference needed to build the new
// cable.
int newTileCost = tile.SpawnAmountOnDeconstruct;
int finalCost = newTileCost - oldTileCost;
// Finally, consume the cables in the hands using the final cost
// we found.
Inventory.ServerConsume(interaction.HandSlot, finalCost);
}
public void AddElectricalNode(Vector3Int position, ElectricalCableTile electricalCableTile, bool AddTile = false)
{
var checkPos = position;
checkPos.z = 0;
var metaData = metaDataLayer.Get(checkPos, true);
var newdata = new ElectricalMetaData();
newdata.Initialise(electricalCableTile, metaData, position, this);
metaData.ElectricalData.Add(newdata);
if (AddTile)
{
if (electricalCableTile != null)
{
if (UnderFloorLayer == null)
{
underFloorLayer = GetComponentInChildren <UnderFloorLayer>();
}
if (UnderFloorLayer != null)
{
UnderFloorLayer.SetTile(position, electricalCableTile, Matrix4x4.identity);
}
}
}
}
/// <summary>
/// [Message Handler] Perform cable cutting interaction on server side
/// </summary>
private void ServerPerformCableCuttingInteraction(NetworkConnection conn, CableCuttingWindow.CableCuttingMessage message)
{
// get object at target position
GameObject hit = MouseUtils.GetOrderedObjectsAtPoint(message.targetWorldPosition).FirstOrDefault();
// get matrix
Matrix matrix = hit.GetComponentInChildren <Matrix>();
// return if matrix is null
if (matrix == null)
{
return;
}
// convert world position to cell position and set Z value to Z value from message
Vector3Int targetCellPosition = matrix.MetaTileMap.WorldToCell(message.targetWorldPosition);
targetCellPosition.z = message.positionZ;
// get electical tile from targetCellPosition
ElectricalCableTile electricalCable = matrix.UnderFloorLayer.GetTileUsingZ(targetCellPosition) as ElectricalCableTile;
if (electricalCable == null)
{
return;
}
// add messages to chat
string othersMessage = Chat.ReplacePerformer(othersStartActionMessage, message.performer);
Chat.AddActionMsgToChat(message.performer, performerStartActionMessage, othersMessage);
// source: ElectricalCableDeconstruction.cs
var metaDataNode = matrix.GetMetaDataNode(targetCellPosition);
foreach (var ElectricalData in metaDataNode.ElectricalData)
{
if (ElectricalData.RelatedTile != electricalCable)
{
continue;
}
// Electrocute the performer. If shock is painful enough, cancel the interaction.
ElectricityFunctions.WorkOutActualNumbers(ElectricalData.InData);
float voltage = ElectricalData.InData.Data.ActualVoltage;
var electrocution = new Electrocution(voltage, message.targetWorldPosition, "cable");
var performerLHB = message.performer.GetComponent <LivingHealthBehaviour>();
var severity = performerLHB.Electrocute(electrocution);
if (severity > LivingShockResponse.Mild)
{
return;
}
ElectricalData.InData.DestroyThisPlease();
Spawn.ServerPrefab(electricalCable.SpawnOnDeconstruct, message.targetWorldPosition,
count: electricalCable.SpawnAmountOnDeconstruct);
return;
}
}
public void AddElectricalNode(Vector3Int position, ElectricalCableTile wireConnect)
{
var checkPos = position;
checkPos.z = 0;
var metaData = metaDataLayer.Get(checkPos, true);
var newdata = new ElectricalMetaData();
newdata.Initialise(wireConnect, metaData, position, this);
metaData.ElectricalData.Add(newdata);
}
public void Initialise(ElectricalCableTile DataToTake, MetaDataNode metaDataNode, Vector3Int searchVec, Matrix locatedon)
{
RelatedTile = DataToTake;
IsOn = metaDataNode;
InData = new IntrinsicElectronicData();
InData.SetUp(DataToTake);
InData.MetaDataPresent = this;
NodeLocation = searchVec;
Locatedon = locatedon;
InData.MetaDataPresent = this;
InData.Present = null;
}
private void UnderFloorElectricalSetTile(Connection WireEndA, Connection WireEndB,
PowerTypeCategory powerTypeCategory, Vector3Int position, ElectricalMetaData newdata = null)
{
ElectricalCableTile Tile = ElectricityFunctions.RetrieveElectricalTile(WireEndA, WireEndB, powerTypeCategory);
if (newdata != null)
{
newdata.RelatedTile = Tile;
}
if (Tile != null)
{
AddUnderFloorTile(position, Tile, Matrix4x4.identity, Color.white);
}
}
public void AddElectricalNode(Vector3Int position, ElectricalCableTile electricalCableTile, bool AddTile = false)
{
var checkPos = position;
checkPos.z = 0;
var metaData = metaDataLayer.Get(checkPos, true);
var newdata = new ElectricalMetaData();
newdata.Initialise(electricalCableTile, metaData, position, this);
metaData.ElectricalData.Add(newdata);
if (AddTile)
{
if (electricalCableTile != null)
{
AddUnderFloorTile(position, electricalCableTile, Matrix4x4.identity, Color.white);
}
}
}
public void AddElectricalNode(Vector3Int position, WireConnect wireConnect)
{
var metaData = metaDataLayer.Get(position, true);
var newdata = new ElectricalMetaData();
newdata.Initialise(wireConnect, metaData, position, this);
metaData.ElectricalData.Add(newdata);
ElectricalCableTile Tile = null;
string Compound;
if (newdata.InData.WireEndA < newdata.InData.WireEndB)
{
Compound = newdata.InData.WireEndA + "_" + newdata.InData.WireEndB;
}
else
{
Compound = newdata.InData.WireEndB + "_" + newdata.InData.WireEndA;
}
int spriteIndex = WireDirections.GetSpriteIndex(Compound);
switch (newdata.InData.Categorytype)
{
case PowerTypeCategory.StandardCable:
Tile = ElectricalManager.Instance.MediumVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.LowVoltageCable:
Tile = ElectricalManager.Instance.LowVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.HighVoltageCable:
Tile = ElectricalManager.Instance.HighVoltageCables.Tiles[spriteIndex];
break;
}
newdata.RelatedTile = Tile;
if (Tile != null)
{
if (metaTileMap != null)
{
metaTileMap.SetTile(position, Tile);
}
}
}
public void AddElectricalNode(Vector3Int position, ElectricalCableTile electricalCableTile, bool AddTile = false)
{
var checkPos = position;
checkPos.z = 0;
var metaData = metaDataLayer.Get(checkPos, true);
if (AddTile)
{
if (electricalCableTile != null)
{
position = TileChangeManager.UpdateTile(position, electricalCableTile);
}
}
var newdata = new ElectricalMetaData();
newdata.Initialise(electricalCableTile, metaData, position, this);
metaData.ElectricalData.Add(newdata);
}
private void UnderFloorElectricalSetTile(Connection WireEndA, Connection WireEndB, PowerTypeCategory powerTypeCategory, Vector3Int position, ElectricalMetaData newdata = null)
{
ElectricalCableTile Tile = ElectricityFunctions.RetrieveElectricalTile(WireEndA, WireEndB, powerTypeCategory);
if (newdata != null)
{
newdata.RelatedTile = Tile;
}
if (Tile != null)
{
if (UnderFloorLayer == null)
{
underFloorLayer = GetComponentInChildren <UnderFloorLayer>();
}
if (UnderFloorLayer != null)
{
UnderFloorLayer.SetTile(position, Tile, Matrix4x4.identity);
}
}
}
public void EditorAddElectricalNode(Vector3Int position, WireConnect wireConnect)
{
var ElectricalManager = FindObjectOfType <ElectricalManager>();
ElectricalCableTile Tile = null;
string Compound;
if (wireConnect.InData.WireEndA < wireConnect.InData.WireEndB)
{
Compound = wireConnect.InData.WireEndA + "_" + wireConnect.InData.WireEndB;
}
else
{
Compound = wireConnect.InData.WireEndB + "_" + wireConnect.InData.WireEndA;
}
int spriteIndex = WireDirections.GetSpriteIndex(Compound);
switch (wireConnect.InData.Categorytype)
{
case PowerTypeCategory.StandardCable:
Tile = ElectricalManager.MediumVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.LowVoltageCable:
Tile = ElectricalManager.LowVoltageCables.Tiles[spriteIndex];
break;
case PowerTypeCategory.HighVoltageCable:
Tile = ElectricalManager.HighVoltageCables.Tiles[spriteIndex];
break;
}
if (Tile != null)
{
if (metaTileMap != null)
{
metaTileMap.SetTile(position, Tile);
}
}
}
