protected FunctionLedMatrix(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int[] parameter) : base(circuitState, parameter) { this.circuitSymbol = symbols.ToList(); this.Matrix = (LedMatrix)this.circuitSymbol[0].Circuit; this.BitPerLed = this.Matrix.Colors; this.project = this.circuitSymbol[0].LogicalCircuit.CircuitProject.ProjectSet.Project; }
private void ReportFunctions(LogicalCircuit root) { try { CircuitMap map = new CircuitMap(root); CircuitState state = map.Apply(1); Dictionary <string, int> func = new Dictionary <string, int>(); foreach (CircuitFunction f in state.Functions) { string name = f.ReportName; if (func.ContainsKey(name)) { func[name]++; } else { func.Add(name, 1); } } this.Functions = new List <string>(func.Keys); this.Functions.Sort(StringComparer.Ordinal); this.Usage = func; } catch (Exception exception) { this.BuildMapException = exception; } }
public WireDisplayControl(Canvas canvas, Point point, Wire wire) { this.InitializeComponent(); Panel.SetZIndex(this, int.MaxValue); Canvas.SetLeft(this, point.X - 3); Canvas.SetTop(this, point.Y - 3); canvas.Children.Add(this); this.UpdateLayout(); if(this.CaptureMouse() && Mouse.LeftButton == MouseButtonState.Pressed) { this.editor = App.Mainframe.Editor; CircuitMap map = this.editor.CircuitRunner.VisibleMap; Tracer.Assert(wire.LogicalCircuit == map.Circuit); this.parameter = map.StateIndexes(wire).ToArray(); this.circuitState = this.editor.CircuitRunner.CircuitState; if(0 < this.parameter.Length && this.circuitState != null) { this.state = new State[this.parameter.Length]; this.bitWidth.Text = Properties.Resources.WireDisplayBitWidth(this.parameter.Length); this.timer = new DispatcherTimer(DispatcherPriority.Normal, App.Mainframe.Dispatcher); this.timer.Tick += TimerTick; this.timer.Interval = new TimeSpan(0, 0, 0, 0, 1000 / (this.editor.IsMaximumSpeed ? 25 : Math.Min(25, this.editor.Frequency * 4))); } else { this.bitWidth.Text = Properties.Resources.WireDisplayDisconnected; this.display.Visibility = Visibility.Collapsed; } } else { this.Cancel(); } }
public FunctionAndNot3(CircuitState circuitState, int[] parameter, int result) : base(circuitState, parameter, result) { Tracer.Assert(parameter.Length == 3); this.param0 = parameter[0]; this.param1 = parameter[1]; this.param2 = parameter[2]; }
public FunctionSensor(CircuitState circuitState, CircuitSymbol symbol, int[] result) : base(circuitState, null, result) { this.CircuitSymbol = symbol; Tracer.Assert(this.BitWidth == result.Length); switch (this.Sensor.SensorType) { case SensorType.Series: case SensorType.Loop: this.sensorValue = new SeriesValue(this.Sensor.Data, this.Sensor.SensorType == SensorType.Loop, this.Sensor.BitWidth); break; case SensorType.Random: this.sensorValue = new RandomValue(this.Sensor.Data, this.Sensor.BitWidth, this.CircuitState.Random); break; case SensorType.Manual: this.sensorValue = new ManualValue(this.Sensor.Data, this.Sensor.BitWidth); break; default: Tracer.Fail(); this.sensorValue = null; break; } }
public FunctionGraphicsArray( CircuitState circuitState, int[] address, int[] inputData, int[] outputData, int write, IEnumerable <CircuitSymbol> symbols ) : base(circuitState, FunctionMemory.Input(address, null, inputData, write), outputData) { this.circuitSymbol = symbols.ToList(); Tracer.Assert(0 < this.circuitSymbol.Count); GraphicsArray graphicsArray = (GraphicsArray)this.circuitSymbol[0].Circuit; this.project = graphicsArray.CircuitProject.ProjectSet.Project; this.address = address; this.inputData = inputData; this.write = write; this.writeOn = graphicsArray.WriteOn1 ? State.On1 : State.On0; Tracer.Assert(this.inputData.Length == outputData.Length && this.inputData.Length == graphicsArray.DataBitWidth); this.bitsPerPixel = graphicsArray.BitsPerPixel; this.drawingRect = new Int32Rect(0, 0, graphicsArray.Width, graphicsArray.Height); int w = this.drawingRect.Width * this.bitsPerPixel; this.memoryStride = w / this.DataBitWidth + (((w % this.DataBitWidth) == 0) ? 0 : 1); int byteStride = w / 8 + (((w % 8) == 0) ? 0 : 1); this.bitmapStride = Math.Max(byteStride * 8, this.memoryStride * this.DataBitWidth) / 8; Tracer.Assert(this.memoryStride * this.DataBitWidth <= this.bitmapStride * 8); this.zoom = graphicsArray.Zoom; switch (graphicsArray.OnStart) { case MemoryOnStart.Random: this.data = this.Allocate(); circuitState.Random.NextBytes(this.data); break; case MemoryOnStart.Zeros: this.data = this.Allocate(); break; case MemoryOnStart.Ones: this.data = this.Allocate(); for (int i = 0; i < this.data.Length; i++) { this.data[i] = 0xFF; } break; case MemoryOnStart.Data: default: Tracer.Fail(); break; } }
protected CircuitFunction(CircuitState circuitState, int[] parameter, int[] result) { this.CircuitState = circuitState; this.parameter = parameter ?? CircuitFunction.EmptyList; this.result = result ?? CircuitFunction.EmptyList; this.result0 = (0 < this.result.Length) ? this.result[0] : -1; this.CircuitState.DefineFunction(this); }
protected CircuitFunction(CircuitState circuitState, int[] parameter, int[] result) { this.CircuitState = circuitState; this.parameter = (parameter == null) ? CircuitFunction.EmptyList : parameter; this.result = (result == null) ? CircuitFunction.EmptyList : result; this.result0 = (0 < this.result.Length) ? this.result[0] : -1; this.CircuitState.DefineFunction(this); }
public FunctionOrNot5(CircuitState circuitState, int[] parameter, int result) : base(circuitState, parameter, result) { Tracer.Assert(parameter.Length == 5); this.param0 = parameter[0]; this.param1 = parameter[1]; this.param2 = parameter[2]; this.param3 = parameter[3]; this.param4 = parameter[4]; }
// jkb end public FunctionRam(CircuitState circuitState, int[] address, int[] inputData, int[] outputData, int write, Memory memory) : base( circuitState, address, inputData, outputData, write, memory) { // jkb: remember this guy if its a keyboard if (this.Memory.MapKeyboard == MemoryMapKeyboard.Hack) { keyboardRAM = this; } }
public FunctionSound(CircuitState circuitState, int parameter) : base(circuitState, parameter) { if (FunctionSound.player == null) { FunctionSound.player = new SoundPlayer(Assembly.GetExecutingAssembly().GetManifestResourceStream("LogicCircuit.Properties.default.wav")); FunctionSound.player.LoadAsync(); } FunctionSound.playCount = 0; }
public FunctionLed(CircuitState circuitState, IEnumerable<CircuitSymbol> symbols, int parameter) : base(circuitState, parameter) { if(FunctionLed.stateBrush == null) { FunctionLed.stateBrush = new Brush[3]; FunctionLed.stateBrush[(int)State.Off] = (Brush)App.CurrentApp.FindResource("LedOff"); FunctionLed.stateBrush[(int)State.On0] = (Brush)App.CurrentApp.FindResource("LedOn0"); FunctionLed.stateBrush[(int)State.On1] = (Brush)App.CurrentApp.FindResource("LedOn1"); } this.circuitSymbol = symbols.ToList(); this.project = this.circuitSymbol[0].LogicalCircuit.CircuitProject.ProjectSet.Project; }
protected CircuitFunction(CircuitState circuitState, int[] parameter, int minimumParameterCount, int result) : this(circuitState, parameter, new int[] { result }) { if (parameter == null) { throw new ArgumentNullException(nameof(parameter)); } if (parameter.Length < minimumParameterCount) { throw new ArgumentException(Properties.Resources.FunctionParameter(this.Name, minimumParameterCount)); } }
public FunctionProbe(CircuitSymbol symbol, CircuitState circuitState, int[] parameter, int capacity) : base(circuitState, parameter) { Tracer.Assert(0 < this.BitWidth && this.BitWidth <= BasePin.MaxBitWidth); this.CircuitSymbol = symbol; this.tickHistory = new History <State> [this.BitWidth]; for (int i = 0; i < this.tickHistory.Length; i++) { this.tickHistory[i] = new History <State>(capacity); } this.valueHistory = new History <long>(capacity); this.valueHistory.Add(this.Pack()); }
/// <summary> /// Creates function. Assumes parameter layout: first goes columns states starting from column 0, bit 0 to bit 2. After all columns goes rows they are one bit wide. /// </summary> /// <param name="circuitState"></param> /// <param name="symbol"></param> /// <param name="parameter"></param> public FunctionLedMatrixSelector(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int[] parameter) : base(circuitState, symbols, parameter) { LedMatrix matrix = this.Matrix; this.row = new State[matrix.Rows]; int columns = matrix.Columns; this.column = new int[columns]; this.columnChanged = new bool[columns]; this.cell = new int[this.column.Length * this.row.Length]; this.cellFlip = new int[this.column.Length * this.row.Length]; this.rowParameter = columns * this.BitPerLed; }
protected FunctionMemory( CircuitState circuitState, int[] address, int[] inputData, int[] outputData, int[] address2, int[] outputData2, int write, Memory memory ) : base(circuitState, FunctionMemory.Input(address, address2, inputData, write), FunctionMemory.Output(outputData, outputData2)) { this.address = address; this.address2 = address2; this.inputData = inputData; this.outputData = outputData; this.outputData2 = outputData2; this.Memory = memory; if (inputData != null) { Tracer.Assert(memory.Writable); Tracer.Assert(this.inputData.Length == this.outputData.Length); this.write = write; this.writeOn = this.Memory.WriteOn1 ? State.On1 : State.On0; switch (this.Memory.OnStart) { case MemoryOnStart.Random: this.data = this.Allocate(); circuitState.Random.NextBytes(this.data); break; case MemoryOnStart.Zeros: this.data = this.Allocate(); break; case MemoryOnStart.Ones: this.data = this.Allocate(); for (int i = 0; i < this.data.Length; i++) { this.data[i] = 0xFF; } break; case MemoryOnStart.Data: this.data = memory.MemoryValue(); break; default: Tracer.Fail(); break; } } else { Tracer.Assert(!memory.Writable); this.write = -1; this.data = memory.MemoryValue(); } }
public FunctionButton(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int result) : base(circuitState, State.On0, result) { this.circuitSymbol = symbols.ToList(); this.project = this.circuitSymbol[0].LogicalCircuit.CircuitProject.ProjectSet.Project; this.isToggle = ((CircuitButton)this.circuitSymbol[0].Circuit).IsToggle; if (this.isToggle && FunctionButton.stateBrush == null) { FunctionButton.stateBrush = new Brush[] { (Brush)App.CurrentApp.FindResource("Led7SegmentOff"), (Brush)App.CurrentApp.FindResource("Led7SegmentOn0"), (Brush)App.CurrentApp.FindResource("Led7SegmentOn1") }; } }
public static FunctionAndNot Create(CircuitState circuitState, int[] parameter, int result) { switch (parameter.Length) { case 1: return(new FunctionAndNot1(circuitState, parameter, result)); case 2: return(new FunctionAndNot2(circuitState, parameter, result)); case 3: return(new FunctionAndNot3(circuitState, parameter, result)); case 4: return(new FunctionAndNot4(circuitState, parameter, result)); case 5: return(new FunctionAndNot5(circuitState, parameter, result)); default: return(new FunctionAndNotCommon(circuitState, parameter, result)); } }
public TableChank(LogicalCircuit logicalCircuit) { this.LogicalCircuit = TableChank.Copy(logicalCircuit); this.Plug(); // Create map and state CircuitMap circuitMap = new CircuitMap(this.LogicalCircuit); this.CircuitState = circuitMap.Apply(CircuitRunner.HistorySize); this.Inputs.ForEach(s => s.Function = circuitMap.FunctionConstant(s.Symbol)); this.Outputs.ForEach(s => s.Function = circuitMap.FunctionProbe(s.Symbol)); this.Inputs.Where(s => s.Function == null).ToList().ForEach(s => this.Inputs.Remove(s)); this.Outputs.Where(s => s.Function == null).ToList().ForEach(s => this.Outputs.Remove(s)); Tracer.Assert(this.Inputs.All(s => s.Function != null) && this.Outputs.All(s => s.Function != null)); this.InputBitCount = this.Inputs.Sum(p => p.Pin.BitWidth); this.Count = BigInteger.One << this.InputBitCount; circuitMap.TurnOn(); }
public void Allocate(CircuitState circuitState) { Tracer.Assert(this.PrivateIndex == 0); if (this.TriStateGroup != null && 0 < this.TriStateGroup.Count) { if (this.StateIndex == 0) { this.StateIndex = circuitState.ReserveState(); foreach (Result r in this.TriStateGroup) { Tracer.Assert(r == this || r.StateIndex == 0); r.StateIndex = this.StateIndex; } } this.PrivateIndex = circuitState.ReserveState(); Tracer.Assert(0 < this.PrivateIndex); } else { Tracer.Assert(this.StateIndex == 0); this.StateIndex = circuitState.ReserveState(); } Tracer.Assert(0 < this.StateIndex); }
public FunctionLedMatrixIndividual(CircuitState circuitState, IEnumerable <CircuitSymbol> symbols, int[] parameter) : base(circuitState, symbols, parameter) { LedMatrix matrix = this.Matrix; this.state = new int[matrix.Rows * matrix.Columns]; }
protected CircuitFunction(CircuitState circuitState, int[] parameter, int result) : this(circuitState, parameter, 1, result) { }
public FunctionConstant(CircuitState circuitState, CircuitSymbol symbol, int[] result) : base(circuitState, null, result) { this.CircuitSymbol = symbol; Tracer.Assert(this.BitWidth == result.Length); }
public FunctionTriState(CircuitState circuitState, int parameter, int enable, int result) : base( circuitState, new int[] { parameter, enable }, result ) { }
protected CircuitFunction(CircuitState circuitState, int parameter, int result) : this(circuitState, new int[] { parameter }, new int[] { result }) { }
protected Probe(CircuitState circuitState, int[] parameter) : base(circuitState, parameter, null) { this.Init(parameter != null ? parameter.Length : 0); }
public FunctionRam(CircuitState circuitState, int[] address, int[] inputData, int[] outputData, int[] address2, int[] outputData2, int write, Memory memory) : base( circuitState, address, inputData, outputData, address2, outputData2, write, memory ) { }
public FunctionClock(CircuitState circuitState, int result) : base(circuitState, null, new int[] { result }) { this.state = false; }
public FunctionAndNotCommon(CircuitState circuitState, int[] parameter, int result) : base(circuitState, parameter, result) { }
protected FunctionAndNot(CircuitState circuitState, int[] parameter, int result) : base(circuitState, parameter, result) { }