Пример #1
0
    /// <summary>
    /// Update loop that helps implement the sequence that the wire
    /// goes through to place the wire. Based on several conditions, the
    /// state of the wire is changed from starting to be placed, to changing
    /// line positions, to adding lines based on inflection points, to ending
    /// the line on a Logic Node to create the wire. After the sequence is
    /// over, the activeBeingPlaced variable is toggled false to render
    /// the Update loop unsuable.
    /// </summary>
    void Update()
    {
        if (activelyBeingPlaced)
        {
            DrawLineBetweenGO(Input.mousePosition);
            if (Input.GetMouseButtonDown(0))
            {
                bool         isClickedLogicNode = false;
                Vector3      mousePos           = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                Vector2      mousePos2D         = new Vector2(mousePos.x, mousePos.y);
                RaycastHit2D hit = Physics2D.Raycast(mousePos2D, Vector2.zero);
                if (hit.collider != null)
                {
                    if (hit.collider.transform.tag == "LOGIC_NODE")
                    {
                        Debug.Log("Wire: Clicked on logic node!");
                        isClickedLogicNode    = true;
                        this.gameObject.name += " " + hit.collider.gameObject.name;
                    }
                }
                Vector3 mouseWorldPoint = Camera.main.ScreenToWorldPoint(Input.mousePosition);
                if (wireInflectionObjects.Count == 0) //starting position isn't chosen yet
                {
                    if (isClickedLogicNode)
                    { //create StartingLogicNode
                        Debug.Log("Wire: Starting sequence.");

                        GameObject wireInflectionPoint = new GameObject("WIRE_POINT_" + wireInflectionObjects.Count);
                        wireInflectionPoint.AddComponent <WireInflection>();
                        wireInflectionPoint.transform.parent   = DeviceGameObject.transform;
                        wireInflectionPoint.transform.position = new Vector3(mouseWorldPoint.x, mouseWorldPoint.y, 10);
                        wireInflectionObjects.Add(wireInflectionPoint);

                        WireLine                   = this.gameObject.AddComponent <LineRenderer>();
                        WireLine.material          = new Material(Shader.Find("Particles/Alpha Blended Premultiply"));
                        WireLine.startWidth        = (float)0.1;
                        WireLine.endWidth          = (float)0.1;
                        WireLine.sortingLayerName  = "ActiveDevices";
                        WireLine.positionCount     = wireInflectionObjects.Count;
                        WireLine.numCornerVertices = wireInflectionObjects.Count;
                        WireLine.SetPosition(wireInflectionObjects.Count - 1, wireInflectionObjects[wireInflectionObjects.Count - 1].transform.position);
#pragma warning disable CS0618 // Type or member is obsolete
                        WireLine.SetColors(Color.red, Color.red);
#pragma warning restore CS0618 // Type or member is obsolete
                    }
                }
                else if (!isClickedLogicNode)
                {
                    Debug.Log("WIRE: Middle point in sequence.");
                    //create linerenderer, dont set end logic node
                    GameObject wireInflectionPoint = new GameObject("WIRE_POINT_" + wireInflectionObjects.Count);
                    wireInflectionPoint.AddComponent <WireInflection>();
                    wireInflectionPoint.transform.parent   = DeviceGameObject.transform;
                    wireInflectionPoint.transform.position = new Vector3(mouseWorldPoint.x, mouseWorldPoint.y, 10);
                    wireInflectionObjects.Add(wireInflectionPoint);
                    WireLine.positionCount     = wireInflectionObjects.Count;
                    WireLine.numCornerVertices = wireInflectionObjects.Count;
                    WireLine.SetPosition(wireInflectionObjects.Count - 1, wireInflectionObjects[wireInflectionObjects.Count - 1].transform.position);

                    //SetRotation for capsule collider
                    GameObject previousInflectionNode = wireInflectionObjects[wireInflectionObjects.Count - 2];
                    var        pos   = Camera.main.WorldToScreenPoint(previousInflectionNode.transform.position);
                    var        dir   = Input.mousePosition - pos;
                    var        angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg + 90;
                    previousInflectionNode.transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
                    CapsuleCollider2D capCol             = previousInflectionNode.AddComponent <CapsuleCollider2D>();
                    float             distanceBetweenGOs = Vector3.Distance(previousInflectionNode.transform.position, wireInflectionPoint.transform.position);
                    capCol.size   = new Vector2(.1f, distanceBetweenGOs);
                    capCol.offset = new Vector2(0f, -(distanceBetweenGOs / 2));
                }
                else if (isClickedLogicNode)
                {
                    //create linerenderer, set end logic node
                    Debug.Log("WIRE: Ending sequence.");

                    GameObject wireInflectionPoint = new GameObject("WIRE_POINT_" + wireInflectionObjects.Count);
                    wireInflectionPoint.AddComponent <WireInflection>();
                    wireInflectionPoint.transform.parent   = DeviceGameObject.transform;
                    wireInflectionPoint.transform.position = new Vector3(mouseWorldPoint.x, mouseWorldPoint.y, 10);
                    wireInflectionObjects.Add(wireInflectionPoint);
                    WireLine.positionCount     = wireInflectionObjects.Count;
                    WireLine.numCornerVertices = wireInflectionObjects.Count;
                    WireLine.SetPosition(wireInflectionObjects.Count - 1, wireInflectionObjects[wireInflectionObjects.Count - 1].transform.position);


                    //SetRotation for capsule collider
                    GameObject previousInflectionNode = wireInflectionObjects[wireInflectionObjects.Count - 2];
                    var        pos   = Camera.main.WorldToScreenPoint(previousInflectionNode.transform.position);
                    var        dir   = Input.mousePosition - pos;
                    var        angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg + 90;
                    previousInflectionNode.transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
                    CapsuleCollider2D capCol             = previousInflectionNode.AddComponent <CapsuleCollider2D>();
                    float             distanceBetweenGOs = Vector3.Distance(previousInflectionNode.transform.position, wireInflectionPoint.transform.position);
                    capCol.size   = new Vector2(.1f, distanceBetweenGOs);
                    capCol.offset = new Vector2(0f, -(distanceBetweenGOs / 2));

                    //End wire sequence
                    activelyBeingPlaced = false;
                    Destroy(placingText);
                    SetLogicNodePositions();
                    this.gameObject.name += "]";
                }
            }
            //Communicate to collided objects that the wire is being destroyed, then destroy the wire
            else if (Input.GetMouseButtonDown(1))
            {
                LogicNode startLogic = startNode.GetComponent <LogicNode>(); startLogic.SetLogicState((int)LOGIC.INVALID);
                LogicNode endLogic   = endNode.GetComponent <LogicNode>(); endLogic.SetLogicState((int)LOGIC.INVALID);
                Destroy(this.gameObject);
            }
        }
    }
Пример #2
0
    /// <summary>
    /// Checks if the Device is On, and then continues to check all the inputs colliding
    /// node and sets the output nodes to the correct state.
    /// </summary>
    private void ChipIO()
    {
        GameObject select0, select1, select2, enable, z, zinv, input_0, input_1, input_2,
                   input_3, input_4, input_5, input_6, input_7, logic_6, logic_13;

        //GND
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 6, out logic_6))
        {
            LogicNode  logic_behavior    = logic_6.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            //GND pin collision node is not GND
            if (collided_state != (int)LOGIC.LOW)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A Ground Input not set to LOW");
            }
        }
        //VCC
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 13, out logic_13))
        {
            LogicNode  logic_behavior    = logic_13.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state != (int)LOGIC.HIGH)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A VCC Input not set to HIGH");
            }
        }

        /**
         * INPUTs find the collided nodes of the input pins and sets the input's
         * pin state to the collided node's state.
         *
         */
        //MUX Selector 0, Node 11
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 10, out select0))
        {
            LogicNode  logic_behavior    = select0.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Selector 1, Node 10
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 9, out select1))
        {
            LogicNode  logic_behavior    = select1.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Selector 2, Node 9
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 8, out select2))
        {
            LogicNode  logic_behavior    = select2.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }

        //MUX Input 0, Node 4
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 3, out input_0))
        {
            LogicNode  logic_behavior    = input_0.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 1, Node 3
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 2, out input_1))
        {
            LogicNode  logic_behavior    = input_1.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 2, Node 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 1, out input_2))
        {
            LogicNode  logic_behavior    = input_2.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 3, Node 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 0, out input_3))
        {
            LogicNode  logic_behavior    = input_3.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 4, Node 15
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 14, out input_4))
        {
            LogicNode  logic_behavior    = input_4.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 5, Node 14
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 13, out input_5))
        {
            LogicNode  logic_behavior    = input_5.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 6, Node 13
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 12, out input_6))
        {
            LogicNode  logic_behavior    = input_6.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }
        //MUX Input 7, Node 12
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 11, out input_7))
        {
            LogicNode  logic_behavior    = input_7.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }

        //MUX Enable, Node 7
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 6, out enable))
        {
            LogicNode  logic_behavior    = enable.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("MUX 74LS151A input 0 is invalid.");
            }
        }


        //MUX Output Z
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 2, out z))
        {
            LogicNode  logic_behavior = z.GetComponent <LogicNode>();
            GameObject collided_node = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state = collided_behavior.GetLogicState();
            LogicNode  sel0, sel1, sel2, i0, i1, i2, i3, i4, i5, i6, i7, e; //LogicNode references
            sel0 = select0.GetComponent <LogicNode>(); sel1 = select1.GetComponent <LogicNode>(); sel2 = select2.GetComponent <LogicNode>();
            i0   = input_0.GetComponent <LogicNode>(); i1 = input_1.GetComponent <LogicNode>(); i2 = input_2.GetComponent <LogicNode>();
            i3   = input_3.GetComponent <LogicNode>(); i4 = input_4.GetComponent <LogicNode>(); i5 = input_5.GetComponent <LogicNode>();
            i6   = input_6.GetComponent <LogicNode>(); i7 = input_7.GetComponent <LogicNode>(); e = enable.GetComponent <LogicNode>();
            int low = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                    sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                    sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState(i0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState(i1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState(i2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState(i3.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState(i4.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState(i5.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState(i6.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else if (sel0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         sel2.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState(i7.GetCollidingNode().GetComponent <LogicNode>().GetLogicState());
                }
                else
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }

        //MUX Output Z
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 2, out zinv))
        {
            LogicNode  logic_behavior    = zinv.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            LogicNode  zNode; //LogicNode references
            zNode = z.GetComponent <LogicNode>();
            int low     = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (zNode.GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (zNode.GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.HIGH);
                }
                else if (zNode.GetLogicState() == (int)LOGIC.INVALID)
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
    }
Пример #3
0
 public NodePack(LogicNode node, bool addOrRe)
 {
     logicNode   = node;
     addOrRemove = addOrRe;
 }
        public static List <T> filterListByProperties <T>(List <T> all, List <string> properties) where T : InformationObject
        {
            List <LogicNode> requirements = new List <LogicNode>();

            foreach (string f in properties)
            {
                LogicNode logicTree = null;

                while (true)
                {
                    try
                    {
                        Console.Write($"Requiremets for {f}: ");
                        string s = Console.ReadLine();

                        logicTree = LogicConstructor.constructLogicTree(s);
                    }
                    catch (ExpressionException e)
                    {
                        Console.WriteLine("Invalid expression");
                        Console.WriteLine(e.Message);

                        continue;
                    }
                    catch
                    {
                        Console.WriteLine("Invalid expression");
                        Console.WriteLine("Reason - unknown");

                        continue;
                    }

                    break;
                }

                requirements.Add(logicTree);
                Console.WriteLine($"A more explicit version: {requirements.Last()}");
            }

            List <T> matching = new List <T>();

            foreach (T item in all)
            {
                bool fail = false;
                for (int i = 0; i < properties.Count; i++)
                {
                    if (requirements[i].checkObject(item, properties[i]) == false)
                    {
                        fail = true;
                        break;
                    }
                }

                if (fail == false)
                {
                    matching.Add(item);
                }
            }

            return(matching);
        }
Пример #5
0
 public PhysicScanStream(LogicNode logic) : base(logic)
 {
 }
Пример #6
0
 public SpecialEvent(string EventId, LogicNode TriggerCond, List <string> actions)
 {
     this.EventId     = EventId;
     this.TriggerCond = TriggerCond;
     this.actions     = actions;
 }
Пример #7
0
 public void MarkPriority(LogicNode node) => firstWait.Push(node);
Пример #8
0
        public LogicNode CreateSetOpPlan(bool top = true)
        {
            if (top)
            {
                // traversal on top node is the time to examine the setop tree
                Debug.Assert(!IsLeaf());
                VerifySelection();
            }

            if (IsLeaf())
            {
                return(stmt_.CreatePlan());
            }
            else
            {
                LogicNode plan  = null;
                var       lplan = left_.CreateSetOpPlan(false);
                var       rplan = right_.CreateSetOpPlan(false);

                // try to reuse existing operators to implment because users may write
                // SQL code like this and this helps reduce optimizer search space
                //
                switch (op_)
                {
                case "unionall":
                    // union all keeps all rows, including duplicates
                    plan = new LogicAppend(lplan, rplan, this);
                    break;

                case "union":
                    // union collect rows from both sides, and remove duplicates
                    plan = new LogicAppend(lplan, rplan, this);
                    var groupby = new List <Expr>(first_.selection_.CloneList());
                    plan = new LogicAgg(plan, groupby, null, null);
                    break;

                case "except":
                // except keeps left rows not found in right
                case "intersect":
                    // intersect keeps rows found in both sides
                    var filter = FilterHelper.MakeFullComparator(
                        left_.first_.selection_, right_.first_.selection_);
                    var join = new LogicJoin(lplan, rplan);
                    if (op_.Contains("except"))
                    {
                        join.type_ = JoinType.AntiSemi;
                    }
                    if (op_.Contains("intersect"))
                    {
                        join.type_ = JoinType.Semi;
                    }
                    var logfilter = new LogicFilter(join, filter);
                    groupby = new List <Expr>(first_.selection_.CloneList());
                    plan    = new LogicAgg(logfilter, groupby, null, null);
                    break;

                case "exceptall":
                case "intersectall":
                    // the 'all' semantics is a bit confusing than intuition:
                    //  {1,1,1} exceptall {1,1} => {1}
                    //  {1,1,1} intersectall {1,1} => {1,1}
                    //
                    throw new NotImplementedException();

                default:
                    throw new InvalidProgramException();
                }

                return(plan);
            }
        }
Пример #9
0
 public void Validate(LogicNode node)
 {
 }
Пример #10
0
    //public void UnlistWait(LogicNode node)
    //{
    //    waiting.
    //}

    public void Add(LogicNode node)
    {
        gates.Add(node);
        node.manager = this;
        MarkActive(node);
    }
Пример #11
0
 public void Remove(LogicNode node)
 {
     gates.Remove(node);
     node.manager = null;
     MarkInactive(node);
 }
Пример #12
0
 public bool MarkInactive(LogicNode node) =>
 activeEven.Remove(node) || activeOdd.Remove(node);
Пример #13
0
 public void MarkActive(LogicNode node) =>
 ((cycle & 1) == 0 ? activeEven : activeOdd).Add(node);
Пример #14
0
 public void MarkWaiting(LogicNode node) => lastWait.Push(node);
Пример #15
0
    /// <summary>
    /// Checks if the Device is On, and then continues to check all the inputs colliding
    /// node and sets the output nodes to the correct state.
    /// </summary>
    private void ChipIO()
    {
        GameObject logic_0, logic_1, logic_2, logic_3, logic_4, logic_5, logic_6,
                   logic_7, logic_8, logic_9, logic_10, logic_11, logic_12, logic_13;

        //GND
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 6, out logic_6))
        {
            LogicNode  logic_behavior    = logic_6.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            //GND pin collision node is not GND
            if (collided_state != (int)LOGIC.LOW)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS08 Ground Input not set to LOW");
            }
            //GND pin collision node is also GND

            /*
             * else
             * {
             *  logic_behavior.SetLogicState((int)LOGIC.LOW);
             *
             * }
             */
        }
        //VCC
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 13, out logic_13))
        {
            LogicNode  logic_behavior    = logic_13.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state != (int)LOGIC.HIGH)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS08 VCC Input not set to HIGH");
            }

            /*
             * else
             * {
             *  logic_behavior.SetLogicState((int)LOGIC.HIGH);
             * }
             */
        }

        /**
         * INPUTs find the collided nodes of the input pins and sets the input's
         * pin state to the collided node's state.
         *
         */
        //AND INPUT 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 0, out logic_0))
        {
            LogicNode  logic_behavior    = logic_0.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND INPUT 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 1, out logic_1))
        {
            LogicNode  logic_behavior    = logic_1.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND ------OUTPUT------- 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 2, out logic_2))
        {
            LogicNode  logic_behavior = logic_2.GetComponent <LogicNode>();
            GameObject collided_node = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state = collided_behavior.GetLogicState();
            LogicNode  lnode_0, lnode_1; //LogicNode references
            lnode_0 = logic_0.GetComponent <LogicNode>(); lnode_1 = logic_1.GetComponent <LogicNode>();
            int low = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                    lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.HIGH);
                }
                else
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }

        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 3, out logic_3))
        {
            LogicNode  logic_behavior    = logic_3.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 4, out logic_4))
        {
            LogicNode  logic_behavior    = logic_4.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND ------OUTPUT------- 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 5, out logic_5))
        {
            LogicNode  logic_behavior = logic_5.GetComponent <LogicNode>();
            GameObject collided_node = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state = collided_behavior.GetLogicState();
            LogicNode  lnode_0, lnode_1; //LogicNode references
            lnode_0 = logic_3.GetComponent <LogicNode>(); lnode_1 = logic_4.GetComponent <LogicNode>();
            int low = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                    lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.HIGH);
                }
                else
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }

        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 9, out logic_9))
        {
            LogicNode  logic_behavior    = logic_9.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 8, out logic_8))
        {
            LogicNode  logic_behavior    = logic_8.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND ------OUTPUT------- 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 7, out logic_7))
        {
            LogicNode  logic_behavior = logic_7.GetComponent <LogicNode>();
            GameObject collided_node = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state = collided_behavior.GetLogicState();
            LogicNode  lnode_0, lnode_1; //LogicNode references
            lnode_0 = logic_8.GetComponent <LogicNode>(); lnode_1 = logic_9.GetComponent <LogicNode>();
            int low = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                    lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.HIGH);
                }
                else
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }

        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 12, out logic_12))
        {
            LogicNode  logic_behavior    = logic_12.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 11, out logic_11))
        {
            LogicNode  logic_behavior    = logic_11.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("AND 74LS408 input 0 is invalid.");
            }
        }
        //AND ------OUTPUT------- 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 10, out logic_10))
        {
            LogicNode  logic_behavior = logic_10.GetComponent <LogicNode>();
            GameObject collided_node = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state = collided_behavior.GetLogicState();
            LogicNode  lnode_0, lnode_1; //LogicNode references
            lnode_0 = logic_11.GetComponent <LogicNode>(); lnode_1 = logic_12.GetComponent <LogicNode>();
            int low = (int)LOGIC.LOW;
            int invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                    lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.HIGH)
                {
                    logic_behavior.SetLogicState((int)LOGIC.LOW);
                }
                else if (lnode_0.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW &&
                         lnode_1.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == (int)LOGIC.LOW)
                {
                    logic_behavior.SetLogicState((int)LOGIC.HIGH);
                }
                else
                {
                    logic_behavior.SetLogicState((int)LOGIC.INVALID);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
    }
Пример #16
0
        public async Task Given_graph_with_nodes_exposing_flow_facade_When_redirect_to_not_ordered_child_via_facade_Then_will_follow_facade_redirection()
        {
            var root = new LogicNode()
            {
                Name = "root"
            };
            var childA = new TestNode()
            {
                Name     = "nodeA", Parent = root,
                Behavior = f => f.RedirectToChild(1) //redirect to nodeAB instead of nodeAA
            };
            var childB = new LogicNode()
            {
                Name = "nodeB", Parent = root
            };

            root.Children.Add(childA);
            root.Children.Add(childB);

            var nodeAA = new LogicNode()
            {
                Name = "nodeAA", Parent = childA
            };

            childA.Children.Add(nodeAA);

            var nodeAB = new LogicNode()
            {
                Name = "nodeAB", Parent = childA
            };

            childA.Children.Add(nodeAB);

            //to check that a normal flow without redirection with pick A child before B child as expected
            var nodeBA = new LogicNode()
            {
                Name = "nodeBA", Parent = childB
            };

            childB.Children.Add(nodeBA);

            var nodeBB = new LogicNode()
            {
                Name = "nodeBB", Parent = childB
            };

            childB.Children.Add(nodeBB);

            var graph = new LogicGraph()
            {
                Root = root, ExecutionFlow = new OrderedExecutionFlow(new TestFacadeNodeExecutor())
            };

            var trace = new List <NodeVisitResult>();

            await foreach (var visit in graph.Run())
            {
                trace.Add(visit);
            }

            trace.Select(v => v.Node.Name)
            .Should().Equal("root", "nodeA", "nodeAB", "nodeAA", "nodeB", "nodeBA", "nodeBB");
        }
Пример #17
0
 public LogicIndex(LogicNode child, IndexDef def)
 {
     children_.Add(child); def_ = def;
 }
Пример #18
0
 public LogicAnalyze(LogicNode child) => children_.Add(child);
Пример #19
0
    //Method that handles the input and output nodes based on the collisions
    private void ChipIO()
    {
        GameObject logic_0, logic_1, logic_2, logic_3, logic_4, logic_5, logic_6,
                   logic_7, logic_8, logic_9, logic_10, logic_11, logic_12, logic_13;

        //GND
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 6, out logic_6))
        {
            LogicNode  logic_behavior    = logic_6.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            //GND pin collision node is not GND
            if (collided_state != (int)LOGIC.LOW)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("NAND 74LS04 Ground Input not set to LOW");
            }
        }
        //VCC
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 13, out logic_13))
        {
            LogicNode  logic_behavior    = logic_13.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state != (int)LOGIC.HIGH)
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("NAND 74LS04 VCC Input not set to HIGH");
            }
        }

        /**
         * INPUTs find the collided nodes of the input pins and sets the input's
         * pin state to the collided node's state.
         *
         */
        //INV INPUT 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 0, out logic_0))
        {
            LogicNode  logic_behavior    = logic_0.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 0 is invalid.");
            }
        }
        //INV INPUT 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 2, out logic_2))
        {
            LogicNode  logic_behavior    = logic_2.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 2 is invalid.");
            }
        }
        //INV INPUT 3
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 4, out logic_4))
        {
            LogicNode  logic_behavior    = logic_4.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 4 is invalid.");
            }
        }
        //INV INPUT 4
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 8, out logic_8))
        {
            LogicNode  logic_behavior    = logic_8.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 8 is invalid.");
            }
        }
        //INV INPUT 5
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 10, out logic_10))
        {
            LogicNode  logic_behavior    = logic_10.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 10 is invalid.");
            }
        }
        //INV INPUT 6
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 12, out logic_12))
        {
            LogicNode  logic_behavior    = logic_12.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            int        collided_state    = collided_behavior.GetLogicState();
            if (collided_state == (int)LOGIC.INVALID || !IsDeviceOn())
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
                Debug.Log("INV 74LS04 input 12 is invalid.");
            }
        }
        //INV ------OUTPUT----- 1
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 1, out logic_1))
        {
            LogicNode  logic_behavior    = logic_1.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_0.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
        //INV ------OUTPUT----- 2
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 3, out logic_3))
        {
            LogicNode  logic_behavior    = logic_3.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_2.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
        //INV ------OUTPUT----- 3
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 5, out logic_5))
        {
            LogicNode  logic_behavior    = logic_5.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_4.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
        //INV ------OUTPUT----- 4
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 7, out logic_7))
        {
            LogicNode  logic_behavior    = logic_7.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_8.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
        //INV ------OUTPUT----- 5
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 9, out logic_9))
        {
            LogicNode  logic_behavior    = logic_9.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_10.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
        //INV ------OUTPUT----- 6
        if (logic_dictionary.TryGetValue(LOGIC_DEVICE_ID + 11, out logic_11))
        {
            LogicNode  logic_behavior    = logic_11.GetComponent <LogicNode>();
            GameObject collided_node     = logic_behavior.GetCollidingNode();
            LogicNode  collided_behavior = collided_node.GetComponent <LogicNode>();
            LogicNode  input_logic_node  = logic_12.GetComponent <LogicNode>();
            int        high    = (int)LOGIC.HIGH;
            int        low     = (int)LOGIC.LOW;
            int        invalid = (int)LOGIC.INVALID;
            if (IsDeviceOn())
            {
                if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == low)
                {
                    logic_behavior.SetLogicState(high);
                }
                else if (input_logic_node.GetCollidingNode().GetComponent <LogicNode>().GetLogicState() == high)
                {
                    logic_behavior.SetLogicState(low);
                }
                else
                {
                    logic_behavior.SetLogicState(invalid);
                }
            }
            else
            {
                logic_behavior.SetLogicState((int)LOGIC.INVALID);
            }
            collided_behavior.RequestStateChange(logic_behavior.GetLogicState());
        }
    }
Пример #20
0
 public CGroupMember(LogicNode node, CMemoGroup group)
 {
     logic_ = node; group_ = group;
     Debug.Assert(!(Logic() is LogicMemoRef));
 }