Esempio n. 1
0
 public void Connect(params WriteConnection[] connections)
 {
     for (var i = 0; i < this.connections.Length; i++)
     {
         Wire.Connect(this.engine, connections[i], this.connections[i]);
     }
 }
Esempio n. 2
0
        public void TestRun()
        {
            var simulation = new Simulation(10);
            var andGate    = new AndGate(1, simulation);
            var notGate    = new NotGate(1, simulation);

            Wire.Connect(andGate.Output, notGate.Input);

            Assert.AreEqual(Signal.Undefined, andGate.Output.Signal);
            Assert.AreEqual(Signal.Undefined, notGate.Output.Signal);

            andGate.Input1.Signal = Signal.On;
            andGate.Input2.Signal = Signal.Off;

            simulation.SimulateNextTimeframe(); // czas 0 - nie ma żadnych zdarzeń do przetworzenia
            simulation.SimulateNextTimeframe(); // czas 1 - zmiany sygnalu przetworzone na bramce and
            simulation.SimulateNextTimeframe(); // czas 2 - zmiana sygnalu przetworzona na bramce not

            Assert.AreEqual(Signal.Off, andGate.Output.Signal);
            Assert.AreEqual(Signal.On, notGate.Output.Signal);

            andGate.Input2.Signal = Signal.On;
            simulation.SimulateNextTimeframe(); // czas 3 - nie ma żadnych zdarzeń do przetworzenia
            simulation.SimulateNextTimeframe(); // czas 4 - zmiana sygnalu przetworzona na bramce and
            simulation.SimulateNextTimeframe(); // czas 5 - zmiana sygnalu przetworzona na bramce not

            Assert.AreEqual(Signal.On, andGate.Output.Signal);
            Assert.AreEqual(Signal.Off, notGate.Output.Signal);
        }
        public void PowerWireLight()
        {
            PowerSupplier  power = new PowerSupplier();
            Wire           wire  = new Wire();
            IndicatorLight light = new IndicatorLight();

            wire.Connect(power.Output, light.Input);

            Assert.IsFalse(light.Lighting);

            power.On();
            Assert.IsTrue(light.Lighting);
            power.On();
            Assert.IsTrue(light.Lighting);
            power.Off();
            Assert.IsFalse(light.Lighting);
            power.Off();
            Assert.IsFalse(light.Lighting);
            power.Toggle();
            Assert.IsTrue(light.Lighting);
            power.Toggle();
            Assert.IsFalse(light.Lighting);
            power.Toggle();
            Assert.IsTrue(light.Lighting);
            power.Toggle();
            Assert.IsFalse(light.Lighting);

            power.On();
            Assert.IsTrue(light.Lighting);
            light.Input.DisconnectEndpoint();
            Assert.IsFalse(light.Lighting);
            power.On();
            Assert.IsFalse(light.Lighting);
        }
Esempio n. 4
0
        public void ConnectSamePoint()
        {
            IInputEndpoint input1 = new InputEndpoint();
            IInputEndpoint input2 = new InputEndpoint();
            Wire           wire   = new Wire(input1, input2);

            wire.Connect(input1, input1);
        }
Esempio n. 5
0
        public void WireConnectReturnCorrectWire()
        {
            var source = new Output();
            var target = new Input();
            var wire   = Wire.Connect(source, target);

            Assert.AreEqual(wire.Source, source);
            Assert.AreEqual(wire.Target, target);
        }
Esempio n. 6
0
        public FlipFlop(int delay, ISimulation simulation)
            : base(delay, simulation)
        {
            setNorGate   = new NorGate(delay, simulation);
            resetNorGate = new NorGate(delay, simulation);

            Wire.Connect(setNorGate.Output, resetNorGate.Input1);
            Wire.Connect(resetNorGate.Output, setNorGate.Input2);
        }
Esempio n. 7
0
        public void ConnectInnerElements(Guid wireId, Guid sourceSocketId, Guid targetSocketId)
        {
            var sourceSocket = GetInnerOutputById(sourceSocketId);
            var targetSocket = GetInnerInputById(targetSocketId);

            var wire = Wire.Connect(sourceSocket, targetSocket);

            wire.Id = wireId;
            innerWires.Add(wire);
        }
Esempio n. 8
0
        public void ChangesTargetInputAfterSourceOutputChanged()
        {
            var source = new Output();
            var target = new Input();

            Wire.Connect(source, target);

            source.Signal = Signal.On;

            Assert.AreEqual(Signal.On, target.Signal);
        }
Esempio n. 9
0
        public void ConnectNullPointWithoutException()
        {
            Wire wire1 = new Wire();
            Wire wire2 = new Wire(null, null);

            IInputEndpoint input = new InputEndpoint();
            Wire           wire3 = new Wire(input);
            Wire           wire4 = new Wire(input, null);
            Wire           wire5 = new Wire(null, input);

            Assert.IsNotNull(wire1);
            Assert.IsNotNull(wire2);
            Assert.IsNotNull(wire3);
            Assert.IsNotNull(wire4);
            Assert.IsNotNull(wire5);

            wire1.Connect(input, null);
            wire1.Connect(null, input);
            wire1.Connect(null, null);
        }
    public void Load(string chipName, GameObject chipHolder)
    {
        var loadedChip = Instantiate(chipHolder);

        loadedChip.transform.parent = transform;

        List <Chip> topLevelChips = new List <Chip> (GetComponentsInChildren <Chip> ());

        var subChips = GetComponentsInChildren <CustomChip> (includeInactive: true);

        for (int i = 0; i < subChips.Length; i++)
        {
            if (subChips[i].transform.parent == loadedChip.transform)
            {
                subChips[i].gameObject.SetActive(true);
                topLevelChips.Add(subChips[i]);
            }
        }

        //topLevelChips.Sort ((a, b) => a.chipSaveIndex.CompareTo (b.chipSaveIndex));

        var wiringSaveData = ChipLoader.LoadWiringFile(SaveSystem.GetPathToWireSaveFile(chipName));
        int wireIndex      = 0;

        foreach (var savedWire in wiringSaveData.serializableWires)
        {
            Wire loadedWire = GameObject.Instantiate(wirePrefab, parent: loadedChip.transform);
            loadedWire.SetDepth(wireIndex);
            Pin parentPin = topLevelChips[savedWire.parentChipIndex].outputPins[savedWire.parentChipOutputIndex];
            Pin childPin  = topLevelChips[savedWire.childChipIndex].inputPins[savedWire.childChipInputIndex];
            loadedWire.Connect(parentPin, childPin);
            loadedWire.SetAnchorPoints(savedWire.anchorPoints);
            FindObjectOfType <PinAndWireInteraction> ().LoadWire(loadedWire);
            //player.AddWire (loadedWire);

            if (childPin.chip is Bus)
            {
                childPin.transform.position = savedWire.anchorPoints[savedWire.anchorPoints.Length - 1];
            }
            if (parentPin.chip is Bus)
            {
                parentPin.transform.position = savedWire.anchorPoints[0];
            }
            wireIndex++;
        }

        this.loadedChipHolder = loadedChip;
    }
Esempio n. 11
0
 private void UpdateCircuit(bool should_update_anim = true)
 {
     if ((UnityEngine.Object)attachedWire != (UnityEngine.Object)null)
     {
         if (switchedOn)
         {
             attachedWire.Connect();
         }
         else
         {
             attachedWire.Disconnect();
         }
     }
     if (should_update_anim && wasOn != switchedOn)
     {
         KBatchedAnimController component = GetComponent <KBatchedAnimController>();
         component.Play((!switchedOn) ? "on_pst" : "on_pre", KAnim.PlayMode.Once, 1f, 0f);
         component.Queue((!switchedOn) ? "off" : "on", KAnim.PlayMode.Once, 1f, 0f);
         Game.Instance.userMenu.Refresh(base.gameObject);
     }
     wasOn = switchedOn;
 }
Esempio n. 12
0
        public void ConnectLater()
        {
            IInputEndpoint input          = new InputEndpoint();
            Int32          receivedSignal = 0;
            IEndpoint      senderPoint    = null;

            input.Receive += (sdr, signal) =>
            {
                senderPoint    = sdr;
                receivedSignal = signal;
            };

            IOutputEndpoint output = new OutputEndpoint();

            Wire wire = new Wire();

            wire.Connect(input, output);

            output.Produce(1);
            Assert.AreEqual(receivedSignal, 1);

            output.Produce(0);
            Assert.AreEqual(receivedSignal, 0);
        }
Esempio n. 13
0
    static ChipSaveData LoadChipWithWires(SavedChip chipToLoad, Dictionary <string, Chip> previouslyLoadedChips, Wire wirePrefab, ChipEditor chipEditor)
    {
        ChipSaveData loadedChipData = new ChipSaveData();
        int          numComponents  = chipToLoad.savedComponentChips.Length;

        loadedChipData.componentChips = new Chip[numComponents];
        loadedChipData.chipName       = chipToLoad.name;
        loadedChipData.chipColour     = chipToLoad.colour;
        loadedChipData.chipNameColour = chipToLoad.nameColour;
        loadedChipData.creationIndex  = chipToLoad.creationIndex;
        List <Wire> wiresToLoad = new List <Wire>();

        // Spawn component chips (the chips used to create this chip)
        // These will have been loaded already, and stored in the previouslyLoadedChips dictionary
        for (int i = 0; i < numComponents; i++)
        {
            SavedComponentChip componentToLoad = chipToLoad.savedComponentChips[i];
            string             componentName   = componentToLoad.chipName;
            Vector2            pos             = new Vector2((float)componentToLoad.posX, (float)componentToLoad.posY);

            if (!previouslyLoadedChips.ContainsKey(componentName))
            {
                Debug.LogError("Failed to load sub component: " + componentName + " While loading " + chipToLoad.name);
            }

            Chip loadedComponentChip = GameObject.Instantiate(previouslyLoadedChips[componentName], pos, Quaternion.identity, chipEditor.chipImplementationHolder);
            loadedComponentChip.gameObject.SetActive(true);
            loadedChipData.componentChips[i] = loadedComponentChip;

            // Load input pin names
            for (int inputIndex = 0; inputIndex < componentToLoad.inputPins.Length && inputIndex < loadedChipData.componentChips[i].inputPins.Length; inputIndex++)
            {
                loadedChipData.componentChips[i].inputPins[inputIndex].pinName = componentToLoad.inputPins[inputIndex].name;
            }

            // Load output pin names
            for (int ouputIndex = 0; ouputIndex < componentToLoad.outputPins.Length && ouputIndex < loadedChipData.componentChips[i].outputPins.Length; ouputIndex++)
            {
                loadedChipData.componentChips[i].outputPins[ouputIndex].pinName = componentToLoad.outputPins[ouputIndex].name;
            }
        }

        // Connect pins with wires
        for (int chipIndex = 0; chipIndex < chipToLoad.savedComponentChips.Length; chipIndex++)
        {
            Chip loadedComponentChip = loadedChipData.componentChips[chipIndex];
            for (int inputPinIndex = 0; inputPinIndex < loadedComponentChip.inputPins.Length && inputPinIndex < chipToLoad.savedComponentChips[chipIndex].inputPins.Length; inputPinIndex++)
            {
                SavedInputPin savedPin = chipToLoad.savedComponentChips[chipIndex].inputPins[inputPinIndex];
                Pin           pin      = loadedComponentChip.inputPins[inputPinIndex];

                // If this pin should receive input from somewhere, then wire it up to that pin
                if (savedPin.parentChipIndex != -1)
                {
                    Pin connectedPin = loadedChipData.componentChips[savedPin.parentChipIndex].outputPins[savedPin.parentChipOutputIndex];
                    pin.cyclic = savedPin.isCylic;
                    if (Pin.TryConnect(connectedPin, pin))
                    {
                        Wire loadedWire = GameObject.Instantiate(wirePrefab, chipEditor.wireHolder);
                        loadedWire.Connect(connectedPin, pin);
                        wiresToLoad.Add(loadedWire);
                    }
                }
            }
        }

        loadedChipData.wires = wiresToLoad.ToArray();

        return(loadedChipData);
    }
Esempio n. 14
0
    void CheckWire(bool rightArm, float triggerValue, HingeJoint2D connector, CircleCollider2D col)
    {
        if (triggerValue > .5f && !connector.enabled)   // if trigger down
        // find all nearby things on connect layer
        {
            int count = Physics2D.OverlapCircleNonAlloc(col.transform.position, col.radius * col.transform.localScale.x, overlapArr, 1 << 8);

            // find closest object
            Collider2D closestOverlap = null;
            float      distance       = float.PositiveInfinity;
            for (int i = 0; i < count; i++)
            {
                if (overlapArr[i] == rightCol || overlapArr[i] == leftCol)
                {
                    continue;
                }
                float sqr = Vector2.SqrMagnitude(overlapArr[i].transform.position - col.transform.position);
                if (sqr < distance)
                {
                    distance       = sqr;
                    closestOverlap = overlapArr[i];
                }
            }

            // if found any object
            if (closestOverlap)
            {
                connector.enabled = true;
                Rigidbody2D closestRb = closestOverlap.GetComponent <Rigidbody2D>();

                wire.Connect(rightArm, closestOverlap);
                if (rightArm)
                {
                    rightMotorTime = 0.3f;
                }
                else
                {
                    leftMotorTime = 0.3f;
                }

                if (closestRb)
                {
                    connector.connectedBody = closestRb;
                }
                else
                {
                    connector.connectedAnchor = closestOverlap.transform.position;
                }
            }
        }
        else if (triggerValue <= .5f && connector.enabled)       // else disconnect if trigger isnt down
        {
            connector.connectedBody = null;
            connector.enabled       = false;

            // lock it but dont pop it (to combat electricity)
            // this doesnt do shit because arms are all rigidbodies too so f this (saving for later) love john, godbless
            //if (wire.powered) {
            //    Debug.Log("depower");
            //    float mag = rb2d.velocity.magnitude;
            //    mag = Mathf.Min(mag, 1.0f);
            //    rb2d.velocity = rb2d.velocity.normalized * mag;
            //}

            wire.Disconnect(rightArm);
        }
    }