private void Refresh(float dt)
{
UtilityNetworkManager <ElectricalUtilityNetwork, Wire> electricalConduitSystem = Game.Instance.electricalConduitSystem;
if (electricalConduitSystem.IsDirty || dirty)
{
electricalConduitSystem.Update();
IList <UtilityNetwork> networks = electricalConduitSystem.GetNetworks();
while (this.circuitInfo.Count < networks.Count)
{
CircuitInfo circuitInfo = default(CircuitInfo);
circuitInfo.generators = new List <Generator>();
circuitInfo.consumers = new List <IEnergyConsumer>();
circuitInfo.batteries = new List <Battery>();
circuitInfo.inputTransformers = new List <Battery>();
circuitInfo.outputTransformers = new List <Generator>();
CircuitInfo item = circuitInfo;
item.bridgeGroups = new List <WireUtilityNetworkLink> [5];
for (int i = 0; i < item.bridgeGroups.Length; i++)
{
item.bridgeGroups[i] = new List <WireUtilityNetworkLink>();
}
this.circuitInfo.Add(item);
}
Rebuild();
}
}
public async Task ParseCircEvent1Async()
{
string data = "650 CIRC 5 EXTENDED $51BD782616C3EBA543B0D4EE34D7C1CE1ED2291D~Geodude BUILD_FLAGS=NEED_CAPACITY PURPOSE=GENERAL TIME_CREATED=2021-06-10T06:26:32.440036 SOCKS_USERNAME=\"AXNH6A3AVT9863JK4VNWD\" SOCKS_PASSWORD=\"AXNH6A3AVT9863JK4VNWD\"\r\n";
TorControlReply rawReply = await TorControlReplyReaderTest.ParseAsync(data);
CircEvent circEvent = CircEvent.FromReply(rawReply);
Assert.NotNull(circEvent.CircuitInfo);
CircuitInfo info = circEvent.CircuitInfo;
Assert.Equal("5", info.CircuitID);
Assert.Equal(CircStatus.EXTENDED, info.CircStatus);
CircPath circPath = Assert.Single(info.CircPaths);
Assert.Equal("$51BD782616C3EBA543B0D4EE34D7C1CE1ED2291D", circPath.FingerPrint);
Assert.Equal("Geodude", circPath.Nickname);
Assert.Equal(new List <BuildFlag>()
{
BuildFlag.NEED_CAPACITY
}, info.BuildFlags);
Assert.Equal(Purpose.GENERAL, info.Purpose);
Assert.Equal("2021-06-10T06:26:32.440036", info.TimeCreated);
Assert.Equal("AXNH6A3AVT9863JK4VNWD", info.UserName);
Assert.Equal("AXNH6A3AVT9863JK4VNWD", info.UserPassword);
}
public float GetWattsUsedByCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(-1f);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.wattsUsed);
}
public ReadOnlyCollection <Generator> GetGeneratorsOnCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(null);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.generators.AsReadOnly());
}
public ReadOnlyCollection <IEnergyConsumer> GetConsumersOnCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(null);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.consumers.AsReadOnly());
}
public ReadOnlyCollection <Battery> GetTransformersOnCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(null);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.inputTransformers.AsReadOnly());
}
public List <Battery> GetBatteriesOnCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(null);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.batteries);
}
public float GetMinBatteryPercentFullOnCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(0f);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.minBatteryPercentFull);
}
public bool HasConsumers(ushort circuitID)
{
if (circuitID == 65535)
{
return(false);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
return(circuitInfo.consumers.Count > 0);
}
public float GetPowerDraw(ushort circuitID, Generator generator)
{
float result = 0f;
if (circuitID < circuitInfo.Count)
{
CircuitInfo value = circuitInfo[circuitID];
circuitInfo[circuitID] = value;
circuitInfo[circuitID] = value;
}
return(result);
}
private void GraphAddCircuit(CircuitInfo circuitInfo)
{
var circuit = new Circuit(circuitInfo);
_circuits.Add(circuit);
ScaleChangeEvent += circuit.ScaleChange;
if (circuit.Info.CircuitId == 0)
{
_emptyCircuit = circuit;
}
ZoomCanvas.Children.Add(circuit.CircuitCanvas);
}
public bool HasBatteries(ushort circuitID)
{
if (circuitID == 65535)
{
return(false);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
int count = circuitInfo.batteries.Count;
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
return(count + circuitInfo2.inputTransformers.Count > 0);
}
public bool HasGenerators(ushort circuitID)
{
if (circuitID == 65535)
{
return(false);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
int count = circuitInfo.generators.Count;
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
return(count + circuitInfo2.outputTransformers.Count > 0);
}
public bool HasPowerSource(ushort circuitID)
{
if (circuitID == 65535)
{
return(false);
}
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
List <Generator> list = circuitInfo.generators;
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
List <Battery> batteries = circuitInfo2.batteries;
return((list.Count > 0 && (Object)list.Find(FindActiveGenerator) != (Object)null) || (batteries.Count > 0 && (Object)batteries.Find(FindActiveBattery) != (Object)null));
}
public float GetPotentialWattsGeneratedByCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(-1f);
}
float num = 0f;
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
List <Generator> list = circuitInfo.generators;
foreach (Generator item in list)
{
num += item.WattageRating;
}
return(num);
}
private void CheckCircuitOverloaded(float dt, int id, float watts_used)
{
UtilityNetworkManager <ElectricalUtilityNetwork, Wire> electricalConduitSystem = Game.Instance.electricalConduitSystem;
UtilityNetwork networkByID = electricalConduitSystem.GetNetworkByID(id);
if (networkByID != null)
{
ElectricalUtilityNetwork electricalUtilityNetwork = (ElectricalUtilityNetwork)networkByID;
if (electricalUtilityNetwork != null)
{
ElectricalUtilityNetwork electricalUtilityNetwork2 = electricalUtilityNetwork;
CircuitInfo circuitInfo = this.circuitInfo[id];
electricalUtilityNetwork2.UpdateOverloadTime(dt, watts_used, circuitInfo.bridgeGroups);
}
}
}
public void FlushCircuitStyle(CircuitInfo info, double scale)
{
Info.LineStyle.Size = info.LineStyle.Size;
Info.LineStyle.Type = info.LineStyle.Type;
Info.LineStyle.ForegroundColor = info.LineStyle.ForegroundColor;
Info.LineStyle.BackgroundColor = info.LineStyle.BackgroundColor;
Info.DotStyle.Size = info.DotStyle.Size;
Info.DotStyle.Type = info.DotStyle.Type;
Info.DotStyle.ForegroundColor = info.DotStyle.ForegroundColor;
Info.DotStyle.BackgroundColor = info.DotStyle.BackgroundColor;
foreach (var dot in CircuitDots)
{
dot.FlushDotStyle(Info.DotStyle, scale);
}
ScaleChange(scale);
}
//private void FlushSelectedCanvas(Point endPosition)
//{
// _selectCanvas.Children.Clear();
// Canvas line1 = MyLine.DrawLine(2, 0, endPosition.Y - _startPosition.Y, 1, Colors.Red);
// Canvas line2 = MyLine.DrawLine(2, 0, endPosition.Y - _startPosition.Y, 1, Colors.Red);
// Canvas line3 = MyLine.DrawLine(2, endPosition.X - _startPosition.X, 0, 1, Colors.Red);
// Canvas line4 = MyLine.DrawLine(2, endPosition.X - _startPosition.X, 0, 1, Colors.Red);
// Canvas.SetLeft(line2, endPosition.X - _startPosition.X);
// Canvas.SetTop(line4, endPosition.Y - _startPosition.Y);
// _selectCanvas.Children.Add(line1);
// _selectCanvas.Children.Add(line2);
// _selectCanvas.Children.Add(line3);
// _selectCanvas.Children.Add(line4);
//}
//private void Mask_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
//{
// ZoomCanvas.MouseMove += image_MouseMove;
// ZoomCanvas.MouseLeftButtonUp += Mask_MouseLeftButtonUp;
// _startPosition = e.GetPosition(ZoomCanvas);
// Canvas.SetLeft(_selectCanvas, e.GetPosition(ZoomCanvas).X);
// Canvas.SetTop(_selectCanvas, e.GetPosition(ZoomCanvas).Y);
//}
//private void image_MouseMove(object sender, MouseEventArgs e)
//{
// if (e.LeftButton == MouseButtonState.Pressed)
// {
// _selectCanvas.Opacity = 1;
// FlushSelectedCanvas(e.GetPosition(ZoomCanvas));
// }
// else
// {
// _selectCanvas.Opacity = 0;
// ZoomCanvas.MouseMove -= image_MouseMove;
// ZoomCanvas.MouseLeftButtonUp -= Mask_MouseLeftButtonUp;
// }
//}
//private void Mask_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
//{
// Canvas board = sender as Canvas;
// ZoomCanvas.MouseMove -= image_MouseMove;
// ZoomCanvas.MouseLeftButtonUp -= Mask_MouseLeftButtonUp;
// _selectCanvas.Opacity = 0;
//}
#endregion
#region 回路
#region 添加
private void MenuAddCircuit_Click(object sender, RoutedEventArgs e)
{
var info = new CircuitInfo
{
ParentCableId = Cable.CableId,
CircuitId = _circuits.Max(circuit => circuit.Info.CircuitId) + 1
};
info.Name = "回路" + info.CircuitId;
var newCircuit = new GraphicalConfigCircuit(info)
{
Owner = this
};
if (newCircuit.ShowDialog() == true)
{
GraphAddCircuit(newCircuit.CurCircuit);
}
}
public float GetWattsGeneratedByCircuit(ushort circuitID)
{
if (circuitID == 65535)
{
return(-1f);
}
float num = 0f;
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
List <Generator> list = circuitInfo.generators;
foreach (Generator item in list)
{
if (!((Object)item == (Object)null) && item.GetComponent <Operational>().IsActive)
{
num += item.WattageRating;
}
}
return(num);
}
public async Task ParseCircEvent2Async()
{
string data = "650 CIRC 16 LAUNCHED BUILD_FLAGS=NEED_CAPACITY PURPOSE=GENERAL TIME_CREATED=2021-06-10T05:42:43.808915\r\n";
TorControlReply rawReply = await TorControlReplyReaderTest.ParseAsync(data);
CircEvent circEvent = CircEvent.FromReply(rawReply);
Assert.NotNull(circEvent.CircuitInfo);
CircuitInfo info = circEvent.CircuitInfo;
Assert.Equal("16", info.CircuitID);
Assert.Equal(CircStatus.LAUNCHED, info.CircStatus);
Assert.Equal(new List <BuildFlag>()
{
BuildFlag.NEED_CAPACITY
}, info.BuildFlags);
Assert.Equal(Purpose.GENERAL, info.Purpose);
Assert.Equal("2021-06-10T05:42:43.808915", info.TimeCreated);
}
public float GetWattsNeededWhenActive(ushort circuitID)
{
if (circuitID == 65535)
{
return(-1f);
}
float num = 0f;
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
foreach (IEnergyConsumer consumer in circuitInfo.consumers)
{
num += consumer.WattsNeededWhenActive;
}
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
foreach (Battery inputTransformer in circuitInfo2.inputTransformers)
{
num += inputTransformer.WattsNeededWhenActive;
}
return(num);
}
private void BtnModifyAllStyle_Click(object sender, RoutedEventArgs e)
{
var info = new CircuitInfo
{
ParentCableId = Cable.CableId,
Name = "回路"
};
var newCircuit = new GraphicalConfigCircuit(info)
{
Owner = this
};
if (newCircuit.ShowDialog() != true)
{
return;
}
foreach (var circuit in _circuits)
{
circuit.FlushCircuitStyle(newCircuit.CurCircuit, _zoomScale);
}
CircuitsTreeView.ItemsSource = null;
CircuitsTreeView.ItemsSource = _circuits;
}
public GraphicalConfigCircuit(CircuitInfo circuit)
{
InitializeComponent();
CmbLineColors.ItemsSource = typeof(Colors).GetProperties();
CmbDotFgColors.ItemsSource = typeof(Colors).GetProperties();
CmbDotBgColors.ItemsSource = typeof(Colors).GetProperties();
CurCircuit = circuit;
Grid.DataContext = CurCircuit;
foreach (var item in typeof(Colors).GetProperties())
{
try
{
var color = (Color)ColorConverter.ConvertFromString(item.Name);
if (color == circuit.LineStyle.ForegroundColor)
{
CmbLineColors.SelectedItem = typeof(Colors).GetProperty(item.Name);
}
if (color == circuit.DotStyle.ForegroundColor)
{
CmbDotFgColors.SelectedItem = typeof(Colors).GetProperty(item.Name);
}
if (color == circuit.DotStyle.BackgroundColor)
{
CmbDotBgColors.SelectedItem = typeof(Colors).GetProperty(item.Name);
}
}
catch (Exception e)
{
LogControl.LogError(e);
}
}
CmbLineWidth.SelectedIndex = Convert.ToInt32(circuit.LineStyle.Size) - 1;
}
} //回路线列表
public Circuit(CircuitInfo circuit)
{
if (circuit == null)
{
CpldLog.LogControl.LogError("创建回路失败，无效的回路信息");
return;
}
CircuitCanvas = new Canvas();
Info = circuit;
if (Info.LineStyle == null)
{
Info.LineStyle = new CpldDB.Style
{
Type = 1,
Size = 1,
ForegroundColor = Colors.Black,
BackgroundColor = Colors.Transparent
};
}
if (circuit.DotStyle == null)
{
Info.DotStyle = new CpldDB.Style
{
Type = 1,
Size = 5,
ForegroundColor = Colors.White,
BackgroundColor = Colors.White
};
}
CircuitDots = new ObservableCollection <Dot>();
CircuitLines = new ObservableCollection <LineInfo>();
}
public void Sim200msLast(float dt)
{
elapsedTime += dt;
if (!(elapsedTime < 0.2f))
{
elapsedTime -= 0.2f;
for (int i = 0; i < this.circuitInfo.Count; i++)
{
CircuitInfo value = this.circuitInfo[i];
value.wattsUsed = 0f;
activeGenerators.Clear();
List <Generator> list = value.generators;
List <IEnergyConsumer> list2 = value.consumers;
List <Battery> batteries = value.batteries;
List <Generator> outputTransformers = value.outputTransformers;
batteries.Sort((Battery a, Battery b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
bool flag = false;
bool flag2 = list.Count > 0;
for (int j = 0; j < list.Count; j++)
{
Generator generator = list[j];
if (generator.JoulesAvailable > 0f)
{
flag = true;
activeGenerators.Add(generator);
}
}
activeGenerators.Sort((Generator a, Generator b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
if (!flag)
{
for (int k = 0; k < outputTransformers.Count; k++)
{
Generator generator2 = outputTransformers[k];
if (generator2.JoulesAvailable > 0f)
{
flag = true;
}
}
}
float num = 1f;
for (int l = 0; l < batteries.Count; l++)
{
Battery battery = batteries[l];
if (battery.JoulesAvailable > 0f)
{
flag = true;
}
num = Mathf.Min(num, battery.PercentFull);
}
for (int m = 0; m < value.inputTransformers.Count; m++)
{
Battery battery2 = value.inputTransformers[m];
num = Mathf.Min(num, battery2.PercentFull);
}
value.minBatteryPercentFull = num;
if (flag)
{
for (int n = 0; n < list2.Count; n++)
{
IEnergyConsumer energyConsumer = list2[n];
float num2 = energyConsumer.WattsUsed * 0.2f;
if (num2 > 0f)
{
bool flag3 = false;
for (int num3 = 0; num3 < activeGenerators.Count; num3++)
{
Generator g = activeGenerators[num3];
num2 = PowerFromGenerator(num2, g, energyConsumer);
if (num2 <= 0f)
{
flag3 = true;
break;
}
}
if (!flag3)
{
for (int num4 = 0; num4 < outputTransformers.Count; num4++)
{
Generator g2 = outputTransformers[num4];
num2 = PowerFromGenerator(num2, g2, energyConsumer);
if (num2 <= 0f)
{
flag3 = true;
break;
}
}
}
if (!flag3)
{
num2 = PowerFromBatteries(num2, batteries, energyConsumer);
flag3 = (num2 <= 0.01f);
}
if (flag3)
{
value.wattsUsed += energyConsumer.WattsUsed;
}
else
{
value.wattsUsed += energyConsumer.WattsUsed - num2 / 0.2f;
}
energyConsumer.SetConnectionStatus((!flag3) ? ConnectionStatus.Unpowered : ConnectionStatus.Powered);
}
else
{
energyConsumer.SetConnectionStatus((!flag) ? ConnectionStatus.Unpowered : ConnectionStatus.Powered);
}
}
}
else if (flag2)
{
for (int num5 = 0; num5 < list2.Count; num5++)
{
IEnergyConsumer energyConsumer2 = list2[num5];
energyConsumer2.SetConnectionStatus(ConnectionStatus.Unpowered);
}
}
else
{
for (int num6 = 0; num6 < list2.Count; num6++)
{
IEnergyConsumer energyConsumer3 = list2[num6];
energyConsumer3.SetConnectionStatus(ConnectionStatus.NotConnected);
}
}
this.circuitInfo[i] = value;
}
for (int num7 = 0; num7 < this.circuitInfo.Count; num7++)
{
CircuitInfo value2 = this.circuitInfo[num7];
value2.batteries.Sort((Battery a, Battery b) => (a.Capacity - a.JoulesAvailable).CompareTo(b.Capacity - b.JoulesAvailable));
value2.inputTransformers.Sort((Battery a, Battery b) => (a.Capacity - a.JoulesAvailable).CompareTo(b.Capacity - b.JoulesAvailable));
value2.generators.Sort((Generator a, Generator b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
float joules_used = 0f;
ChargeTransformers(value2.inputTransformers, value2.generators, ref joules_used);
ChargeTransformers(value2.inputTransformers, value2.outputTransformers, ref joules_used);
float joules_used2 = 0f;
ChargeBatteries(value2.batteries, value2.generators, ref joules_used2);
ChargeBatteries(value2.batteries, value2.outputTransformers, ref joules_used2);
value2.minBatteryPercentFull = 1f;
for (int num8 = 0; num8 < value2.batteries.Count; num8++)
{
Battery battery3 = value2.batteries[num8];
float percentFull = battery3.PercentFull;
if (percentFull < value2.minBatteryPercentFull)
{
value2.minBatteryPercentFull = percentFull;
}
}
for (int num9 = 0; num9 < value2.inputTransformers.Count; num9++)
{
Battery battery4 = value2.inputTransformers[num9];
float percentFull2 = battery4.PercentFull;
if (percentFull2 < value2.minBatteryPercentFull)
{
value2.minBatteryPercentFull = percentFull2;
}
}
value2.wattsUsed += joules_used / 0.2f;
this.circuitInfo[num7] = value2;
}
for (int num10 = 0; num10 < this.circuitInfo.Count; num10++)
{
CircuitInfo value3 = this.circuitInfo[num10];
value3.batteries.Sort((Battery a, Battery b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
float joules_used3 = 0f;
ChargeTransformers(value3.inputTransformers, value3.batteries, ref joules_used3);
value3.wattsUsed += joules_used3 / 0.2f;
this.circuitInfo[num10] = value3;
}
for (int num11 = 0; num11 < this.circuitInfo.Count; num11++)
{
CircuitInfo value4 = this.circuitInfo[num11];
bool is_connected_to_something_useful = value4.generators.Count + value4.consumers.Count + value4.outputTransformers.Count > 0;
UpdateBatteryConnectionStatus(value4.batteries, is_connected_to_something_useful, num11);
bool flag4 = value4.generators.Count > 0 || value4.outputTransformers.Count > 0;
if (!flag4)
{
foreach (Battery battery5 in value4.batteries)
{
if (battery5.JoulesAvailable > 0f)
{
flag4 = true;
break;
}
}
}
UpdateBatteryConnectionStatus(value4.inputTransformers, flag4, num11);
this.circuitInfo[num11] = value4;
for (int num12 = 0; num12 < value4.generators.Count; num12++)
{
Generator generator3 = value4.generators[num12];
ReportManager.Instance.ReportValue(ReportManager.ReportType.EnergyWasted, 0f - generator3.JoulesAvailable, StringFormatter.Replace(BUILDINGS.PREFABS.GENERATOR.OVERPRODUCTION, "{Generator}", generator3.gameObject.GetProperName()), null);
}
}
for (int num13 = 0; num13 < this.circuitInfo.Count; num13++)
{
CircuitInfo circuitInfo = this.circuitInfo[num13];
CheckCircuitOverloaded(0.2f, num13, circuitInfo.wattsUsed);
}
}
}
/// <summary>
/// 回路の各要素を再帰的に探索して情報を解析する
/// </summary>
/// <param name="target">探索対象要素</param>
/// <param name="circuitInfo">回路情報（初回呼び出しはnullを指定する）</param>
/// <param name="circle">探索サークル（初回呼び出しはnullを指定する）</param>
private static CircuitInfo SearchCircuit(
Element target,
CircuitInfo circuitInfo,
List <Element> circle)
{
if (circuitInfo == null)
{
circuitInfo = new CircuitInfo(
new List <List <Element> >(),
new List <Current>(),
new List <Element>()
);
}
if (circle == null)
{
circle = new List <Element>();
}
circle.Add(target);
circuitInfo.Elements.Add(target);
// target の電流を決める
var prevTerminal = target.GetSearchParam().GetPrev();
var nextTerminal = target.GetSearchParam().GetNext();
if (target.GetSearchParam().current != null)
{
// ignore
}
else if (target.GetSearchParam().GetPrev()._connections.Count == 1)
{
var prev = prevTerminal._connections[0];
if (prev.GetSearchParam().current == null)
{
// 新しい電流
target.GetSearchParam().current = new Current($"電流 {(circuitInfo.Currents.Count + 1).ToString()}");
circuitInfo.Currents.Add(target.GetSearchParam().current);
}
else
{
// prevと同じ電流
target.GetSearchParam().current = prev.GetSearchParam().current;
}
}
else if (prevTerminal._connections.Count > 0)
{
// 新しい電流
target.GetSearchParam().current = new Current($"電流 {(circuitInfo.Currents.Count + 1).ToString()}");
circuitInfo.Currents.Add(target.GetSearchParam().current);
}
// target で分岐している場合、新たな電流の定義・分岐点のマークを行う
for (var i = 0; i < nextTerminal._connections.Count; i++)
{
var nextElement = nextTerminal._connections[i];
if (!circle.Contains(nextElement))
{
nextElement.GetSearchParam().PushPrev(target);
}
if (nextTerminal._connections.Count > 1)
{
if (i != 0)
{
target.GetSearchParam().ForkCount++;
}
if (nextElement.GetSearchParam().current == null)
{
nextElement.GetSearchParam().current =
new Current($"電流 {(circuitInfo.Currents.Count + 1).ToString()}");
circuitInfo.Currents.Add(nextElement.GetSearchParam().current);
}
}
}
// target の先を探索する
foreach (var next in nextTerminal._connections)
{
var c = new List <Element>(circle);
// 最初だったら
if (c.Count == 1)
{
circuitInfo = SearchCircuit(next, circuitInfo, c);
continue;
}
// 戻ってきたら
if (c.Contains(next))
{
// EntryPoint に戻った場合
if (c[0] == next)
{
circuitInfo.Circles.Add(c);
if (!c.First().GetSearchParam().current.Equals(c.Last().GetSearchParam().current) &&
c.First().GetSearchParam().GetPrev()._connections.Count == 1)
{
var duplicatedCurrent = c.Last().GetSearchParam().current;
ReplaceCurrent(c, duplicatedCurrent, c.First().GetSearchParam().current);
circuitInfo.Currents.Remove(duplicatedCurrent);
}
c.ForEach(e => { e.FixParams(); });
}
// 分岐点までさかのぼって探索要パラメータをCleanする
for (var k = c.Count - 1; k > -1; k--)
{
var element = c[k];
var searchParam = element.GetSearchParam();
if (searchParam.ForkCount > 0)
{
searchParam.ForkCount--;
break;
}
if (c[0] != next && !element.isFixed)
{
searchParam.PrevStack.Pop();
element.GetSearchParam().current = null;
}
}
continue;
}
circuitInfo = SearchCircuit(next, circuitInfo, c);
}
return(circuitInfo);
}
public bool SaveCable()
{
if (string.IsNullOrEmpty(CableInfo.CableName))
{
InfoBox.ErrorMsg("请输入产品名");
return(false);
}
bool isProductNameExist;
CacheGraph.IsCableNameExist(CableInfo, CableInfo.CableName, out isProductNameExist);
if (isProductNameExist)
{
InfoBox.ErrorMsg("产品名已存在");
return(false);
}
CableInfo.ModifyDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
CableInfo.CreateUser = UserInfo.UserName;
if (_shortCircuitInfoResult == null)
{
InfoBox.InfoMsg("请取样");
return(false);
}
//加线
CacheGraph.AddCable(CableInfo);
var circuitId = 1;
var dotId = 1;
foreach (var circuit in _shortCircuitInfoResult)
{
//加回路
var circuitInfo = new CircuitInfo
{
ParentCableId = CableInfo.CableId,
CircuitId = circuitId
};
circuitInfo.Name = "回路" + circuitInfo.CircuitId;
CacheGraph.AddCircuit(circuitInfo);
foreach (var dot in circuit)
{
//加点
var dotInfo = new DotInfo
{
ParentCableId = CableInfo.CableId,
ParentPlugId = 0,
ParentCircuitId = circuitId,
DotId = dotId,
PhyAddr = dot,
Name = "点" + dotId,
Position = new Point(20 + 20 * circuit.IndexOf(dot), 20 + 20 * circuitId)
};
CacheGraph.AddDot(dotInfo);
dotId++;
}
circuitId++;
}
InfoBox.InfoMsg(CacheGraph.CacheCopyCable() ? "保存成功" : "保存失败");
return(true);
}
private void DrawErrorLines(IEnumerable <List <string> > shortCircuitList, IEnumerable <List <string> > openCircuitList)
{
try
{
foreach (var circuit in openCircuitList)
{
var info = new CircuitInfo
{
CircuitId = -1,
LineStyle = new CpldDB.Style
{
Type = 1,
Size = 2,
ForegroundColor = Colors.Red,
BackgroundColor = Colors.Transparent,
},
DotStyle = new CpldDB.Style
{
Type = 1,
Size = 4,
ForegroundColor = Colors.Transparent,
BackgroundColor = Colors.Transparent,
},
};
var tmpCircuit = new Circuit(info);
foreach (var dot in circuit)
{
if (_phyAddrMapToDot.ContainsKey(dot))
{
tmpCircuit.CircuitDots.Add((Dot)_phyAddrMapToDot[dot]);
}
}
tmpCircuit.GetAllLines(_zoomScale);
_errorLineCanvas.Children.Add(tmpCircuit.CircuitCanvas);
}
foreach (var circuit in shortCircuitList)
{
var info = new CircuitInfo
{
CircuitId = -1,
LineStyle = new CpldDB.Style
{
Type = 2,
Size = 6,
ForegroundColor = Colors.Green,
BackgroundColor = Colors.Transparent,
},
DotStyle = new CpldDB.Style
{
Type = 1,
Size = 4,
ForegroundColor = Colors.Transparent,
BackgroundColor = Colors.Transparent,
},
};
var tmpCircuit = new Circuit(info);
foreach (var dot in circuit)
{
if (_phyAddrMapToDot.ContainsKey(dot))
{
tmpCircuit.CircuitDots.Add((Dot)_phyAddrMapToDot[dot]);
}
}
tmpCircuit.GetAllLines(_zoomScale);
_errorLineCanvas.Children.Add(tmpCircuit.CircuitCanvas);
}
}
catch (Exception e)
{
LogControl.LogError(e);
throw;
}
}
public async Task ParseReplyAsync()
{
StringBuilder sb = new();
sb.Append("250+circuit-status=\r\n");
sb.Append("1 BUILT $E9F71AC06F29B2110E3FC09016B0E50407444EE2~libertas,$D0423D3A13C18D2ED0F3D5BFD90E13E77C9AD239~d0xkb,$3A9559477D72F71215850C97FA62A0DA7380964B~PawNetBlue BUILD_FLAGS=NEED_CAPACITY PURPOSE=GENERAL TIME_CREATED=2021-05-15T14:04:17.615384\r\n");
sb.Append("2 BUILT $E9F71AC06F29B2110E3FC09016B0E50407444EE2~libertas,$A0FA50A070CFB4B89737A27F3259F92C118A0AF0~pipiska,$7E77CC94D94C08609D70B517FF938CC61C9F8232~pitfall BUILD_FLAGS=NEED_CAPACITY PURPOSE=GENERAL TIME_CREATED=2021-05-15T14:04:18.628885\r\n");
sb.Append("3 BUILT $E9F71AC06F29B2110E3FC09016B0E50407444EE2~libertas,$706A7674A217BA905FE677E82236B7B968A23DB7~rofltor04,$4D4938B725B89561773A161215D88B7C45C43C35~TheGreenDynamo,$18CA339AD0C33EAB035F1D869518F3D2D88BABC0~FreeAssange BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY PURPOSE=HS_CLIENT_HSDIR HS_STATE=HSCI_CONNECTING TIME_CREATED=2021-05-15T14:04:19.353271\r\n");
sb.Append("4 EXTENDED $E9F71AC06F29B2110E3FC09016B0E50407444EE2~libertas BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY PURPOSE=MEASURE_TIMEOUT TIME_CREATED=2021-05-15T14:04:19.631228\r\n");
sb.Append("5 BUILT $E9F71AC06F29B2110E3FC09016B0E50407444EE2~libertas,$31D270A38505D4BFBBCABF717E9FB4BCA6DDF2FF~Belgium,$B411027C926A9BFFCF7DA91E3CAF1856A321EFFD~pulsetor BUILD_FLAGS=IS_INTERNAL,NEED_CAPACITY PURPOSE=HS_CLIENT_REND HS_STATE=HSCR_JOINED REND_QUERY=wasabiukrxmkdgve5kynjztuovbg43uxcbcxn6y2okcrsg7gb6jdmbad TIME_CREATED=2021-05-15T14:04:20.634686\r\n");
sb.Append(".\r\n");
sb.Append("250 OK\r\n");
string data = sb.ToString();
TorControlReply rawReply = await TorControlReplyReaderTest.ParseAsync(data);
Assert.Equal(8, rawReply.ResponseLines.Count);
GetInfoCircuitStatusReply reply = GetInfoCircuitStatusReply.FromReply(rawReply);
Assert.Equal(5, reply.Circuits.Count);
// Circuit #1.
{
CircuitInfo circuitInfo = reply.Circuits[0];
Assert.Equal("1", circuitInfo.CircuitID);
Assert.Equal(CircStatus.BUILT, circuitInfo.CircStatus);
List <CircPath> circPaths = circuitInfo.CircPaths;
Assert.Equal("$E9F71AC06F29B2110E3FC09016B0E50407444EE2", circPaths[0].FingerPrint);
Assert.Equal("libertas", circPaths[0].Nickname);
Assert.Equal("$D0423D3A13C18D2ED0F3D5BFD90E13E77C9AD239", circPaths[1].FingerPrint);
Assert.Equal("d0xkb", circPaths[1].Nickname);
Assert.Equal("$3A9559477D72F71215850C97FA62A0DA7380964B", circPaths[2].FingerPrint);
Assert.Equal("PawNetBlue", circPaths[2].Nickname);
BuildFlag buildFlag = Assert.Single(circuitInfo.BuildFlags);
Assert.Equal(BuildFlag.NEED_CAPACITY, buildFlag);
Assert.Equal(Purpose.GENERAL, circuitInfo.Purpose);
Assert.Equal("2021-05-15T14:04:17.615384", circuitInfo.TimeCreated);
Assert.Null(circuitInfo.Reason);
Assert.Null(circuitInfo.RemoteReason);
Assert.Null(circuitInfo.HsState);
Assert.Null(circuitInfo.RendQuery);
Assert.Null(circuitInfo.UserName);
Assert.Null(circuitInfo.UserPassword);
}
// Circuit #2.
{
CircuitInfo circuitInfo = reply.Circuits[1];
Assert.Equal("2", circuitInfo.CircuitID);
Assert.Equal(CircStatus.BUILT, circuitInfo.CircStatus);
List <CircPath> circPaths = circuitInfo.CircPaths;
Assert.Equal("$E9F71AC06F29B2110E3FC09016B0E50407444EE2", circPaths[0].FingerPrint);
Assert.Equal("libertas", circPaths[0].Nickname);
Assert.Equal("$A0FA50A070CFB4B89737A27F3259F92C118A0AF0", circPaths[1].FingerPrint);
Assert.Equal("pipiska", circPaths[1].Nickname);
Assert.Equal("$7E77CC94D94C08609D70B517FF938CC61C9F8232", circPaths[2].FingerPrint);
Assert.Equal("pitfall", circPaths[2].Nickname);
BuildFlag buildFlag = Assert.Single(circuitInfo.BuildFlags);
Assert.Equal(BuildFlag.NEED_CAPACITY, buildFlag);
Assert.Equal(Purpose.GENERAL, circuitInfo.Purpose);
Assert.Equal("2021-05-15T14:04:18.628885", circuitInfo.TimeCreated);
Assert.Null(circuitInfo.Reason);
Assert.Null(circuitInfo.RemoteReason);
Assert.Null(circuitInfo.HsState);
Assert.Null(circuitInfo.RendQuery);
Assert.Null(circuitInfo.UserName);
Assert.Null(circuitInfo.UserPassword);
}
// Circuit #3.
{
CircuitInfo circuitInfo = reply.Circuits[2];
Assert.Equal("3", circuitInfo.CircuitID);
Assert.Equal(CircStatus.BUILT, circuitInfo.CircStatus);
List <CircPath> circPaths = circuitInfo.CircPaths;
Assert.Equal("$E9F71AC06F29B2110E3FC09016B0E50407444EE2", circPaths[0].FingerPrint);
Assert.Equal("libertas", circPaths[0].Nickname);
Assert.Equal("$706A7674A217BA905FE677E82236B7B968A23DB7", circPaths[1].FingerPrint);
Assert.Equal("rofltor04", circPaths[1].Nickname);
Assert.Equal("$4D4938B725B89561773A161215D88B7C45C43C35", circPaths[2].FingerPrint);
Assert.Equal("TheGreenDynamo", circPaths[2].Nickname);
Assert.Equal("$18CA339AD0C33EAB035F1D869518F3D2D88BABC0", circPaths[3].FingerPrint);
Assert.Equal("FreeAssange", circPaths[3].Nickname);
Assert.Equal(2, circuitInfo.BuildFlags.Count);
Assert.Equal(BuildFlag.IS_INTERNAL, circuitInfo.BuildFlags[0]);
Assert.Equal(BuildFlag.NEED_CAPACITY, circuitInfo.BuildFlags[1]);
Assert.Equal(Purpose.HS_CLIENT_HSDIR, circuitInfo.Purpose);
Assert.Equal(HsState.HSCI_CONNECTING, circuitInfo.HsState);
Assert.Equal("2021-05-15T14:04:19.353271", circuitInfo.TimeCreated);
Assert.Null(circuitInfo.Reason);
Assert.Null(circuitInfo.RemoteReason);
Assert.Null(circuitInfo.RendQuery);
Assert.Null(circuitInfo.UserName);
Assert.Null(circuitInfo.UserPassword);
}
// Circuit #4.
{
CircuitInfo circuitInfo = reply.Circuits[3];
Assert.Equal("4", circuitInfo.CircuitID);
Assert.Equal(CircStatus.EXTENDED, circuitInfo.CircStatus);
List <CircPath> circPaths = circuitInfo.CircPaths;
Assert.Equal("$E9F71AC06F29B2110E3FC09016B0E50407444EE2", circPaths[0].FingerPrint);
Assert.Equal("libertas", circPaths[0].Nickname);
Assert.Equal(2, circuitInfo.BuildFlags.Count);
Assert.Equal(BuildFlag.IS_INTERNAL, circuitInfo.BuildFlags[0]);
Assert.Equal(BuildFlag.NEED_CAPACITY, circuitInfo.BuildFlags[1]);
Assert.Equal(Purpose.MEASURE_TIMEOUT, circuitInfo.Purpose);
Assert.Equal("2021-05-15T14:04:19.631228", circuitInfo.TimeCreated);
Assert.Null(circuitInfo.HsState);
Assert.Null(circuitInfo.Reason);
Assert.Null(circuitInfo.RemoteReason);
Assert.Null(circuitInfo.RendQuery);
Assert.Null(circuitInfo.UserName);
Assert.Null(circuitInfo.UserPassword);
}
// Circuit #5.
{
CircuitInfo circuitInfo = reply.Circuits[4];
Assert.Equal("5", circuitInfo.CircuitID);
Assert.Equal(CircStatus.BUILT, circuitInfo.CircStatus);
List <CircPath> circPaths = circuitInfo.CircPaths;
Assert.Equal("$E9F71AC06F29B2110E3FC09016B0E50407444EE2", circPaths[0].FingerPrint);
Assert.Equal("libertas", circPaths[0].Nickname);
Assert.Equal("$31D270A38505D4BFBBCABF717E9FB4BCA6DDF2FF", circPaths[1].FingerPrint);
Assert.Equal("Belgium", circPaths[1].Nickname);
Assert.Equal("$B411027C926A9BFFCF7DA91E3CAF1856A321EFFD", circPaths[2].FingerPrint);
Assert.Equal("pulsetor", circPaths[2].Nickname);
Assert.Equal(2, circuitInfo.BuildFlags.Count);
Assert.Equal(BuildFlag.IS_INTERNAL, circuitInfo.BuildFlags[0]);
Assert.Equal(BuildFlag.NEED_CAPACITY, circuitInfo.BuildFlags[1]);
Assert.Equal(Purpose.HS_CLIENT_REND, circuitInfo.Purpose);
Assert.Equal(HsState.HSCR_JOINED, circuitInfo.HsState);
Assert.Equal("wasabiukrxmkdgve5kynjztuovbg43uxcbcxn6y2okcrsg7gb6jdmbad", circuitInfo.RendQuery);
Assert.Equal("2021-05-15T14:04:20.634686", circuitInfo.TimeCreated);
Assert.Null(circuitInfo.Reason);
Assert.Null(circuitInfo.RemoteReason);
Assert.Null(circuitInfo.UserName);
Assert.Null(circuitInfo.UserPassword);
}
}
public void Rebuild()
{
for (int i = 0; i < this.circuitInfo.Count; i++)
{
CircuitInfo value = this.circuitInfo[i];
value.generators.Clear();
value.consumers.Clear();
value.batteries.Clear();
value.inputTransformers.Clear();
value.outputTransformers.Clear();
value.minBatteryPercentFull = 1f;
for (int j = 0; j < value.bridgeGroups.Length; j++)
{
value.bridgeGroups[j].Clear();
}
this.circuitInfo[i] = value;
}
consumersShadow.AddRange(consumers);
List <IEnergyConsumer> .Enumerator enumerator = consumersShadow.GetEnumerator();
while (enumerator.MoveNext())
{
IEnergyConsumer current = enumerator.Current;
int powerCell = current.PowerCell;
ushort circuitID = GetCircuitID(powerCell);
if (circuitID != 65535)
{
Battery battery = current as Battery;
if ((Object)battery != (Object)null)
{
Operational component = battery.GetComponent <Operational>();
if ((Object)component == (Object)null || component.IsOperational)
{
CircuitInfo value2 = this.circuitInfo[circuitID];
PowerTransformer powerTransformer = battery.powerTransformer;
if ((Object)powerTransformer != (Object)null)
{
value2.inputTransformers.Add(battery);
}
else
{
value2.batteries.Add(battery);
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
value2.minBatteryPercentFull = Mathf.Min(circuitInfo.minBatteryPercentFull, battery.PercentFull);
}
this.circuitInfo[circuitID] = value2;
}
}
else
{
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
circuitInfo2.consumers.Add(current);
}
}
}
consumersShadow.Clear();
for (int k = 0; k < this.circuitInfo.Count; k++)
{
CircuitInfo circuitInfo3 = this.circuitInfo[k];
circuitInfo3.consumers.Sort((IEnergyConsumer a, IEnergyConsumer b) => a.WattsNeededWhenActive.CompareTo(b.WattsNeededWhenActive));
}
HashSet <Generator> .Enumerator enumerator2 = generators.GetEnumerator();
while (enumerator2.MoveNext())
{
Generator current2 = enumerator2.Current;
int powerCell2 = current2.PowerCell;
ushort circuitID2 = GetCircuitID(powerCell2);
if (circuitID2 != 65535)
{
if (current2.GetType() == typeof(PowerTransformer))
{
CircuitInfo circuitInfo4 = this.circuitInfo[circuitID2];
circuitInfo4.outputTransformers.Add(current2);
}
else
{
CircuitInfo circuitInfo5 = this.circuitInfo[circuitID2];
circuitInfo5.generators.Add(current2);
}
}
}
HashSet <WireUtilityNetworkLink> .Enumerator enumerator3 = bridges.GetEnumerator();
while (enumerator3.MoveNext())
{
WireUtilityNetworkLink current3 = enumerator3.Current;
current3.GetCells(out int linked_cell, out int _);
ushort circuitID3 = GetCircuitID(linked_cell);
if (circuitID3 != 65535)
{
Wire.WattageRating maxWattageRating = current3.GetMaxWattageRating();
CircuitInfo circuitInfo6 = this.circuitInfo[circuitID3];
circuitInfo6.bridgeGroups[(int)maxWattageRating].Add(current3);
}
}
dirty = false;
}
