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();
        }
    }
Beispiel #2
0
    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);
    }
Beispiel #11
0
        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);
            }
        }
    }
Beispiel #17
0
        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);
    }
Beispiel #20
0
    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;
        }
Beispiel #24
0
        }                                                                 //回路线列表

        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);
         }
     }
 }
Beispiel #26
0
    /// <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);
    }
Beispiel #27
0
        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);
        }
Beispiel #28
0
 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;
 }