        public bool ProcessMotion1()
        {
            if (active1.MotionFrameCounter <= 0)
            {
                // Move the piece down by one tile, UNLESS the tile below (or active2's tile below) is occupied.

                DropObject comparator1 = getComparator(active1);
                DropObject comparator2 = getComparator(active2);

                if (active1.ArrayLocY == 0) // If the tile is on the floor, it stops.
                {
                    active1.CurMotionState = DropObject.MotionState.Still;
                    active1.RecalculatePositions(playAreaRect, playAreaX, playAreaY); // juuust in case.
                    active1.MotionFrameCounter = framesPerMotion;
                    return false;
                }

                else if (comparator1 != null) // There's a piece below #1.
                {
                    active1.CurMotionState = DropObject.MotionState.Falling;
                    int dropAmount = 1;
                    while (playField[active1.ArrayLocX, active1.ArrayLocY - dropAmount] == null && active1.ArrayLocY + dropAmount <= playAreaY)
                    {
                        dropAmount++;
                    }
                    Vector2 newTarg = active1.TargetPosition;
                    if (active1.ArrayLocY + dropAmount <= playAreaY)
                    { // We're falling all the way down...
                        active1.ArrayLocY = 0;
                        newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * 1; // The *1 is just for format consistency.
                    }
                    else
                    { // We're falling a now-known number of tiles.
                        active1.ArrayLocY -= dropAmount - 1;
                        newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * active1.ArrayLocY;
                    }
                    active1.TargetPosition = newTarg;
                }

                else if (comparator2 != null && active2.ArrayLocY != 0 // ... OR 2 isn't on the floor, has a piece below it...
                    && active2.ArrayLocX != active1.ArrayLocX) // AND ALSO isn't on the same row as #1...
                { // The tile below #2 is occupied
                    if (comparator == null)
                    {
                        active1.CurMotionState = DropObject.MotionState.Falling;
                        int dropAmount = 1;
                        while (playField[active1.ArrayLocX, active1.ArrayLocY - dropAmount] == null && active1.ArrayLocY + dropAmount <= playAreaY)
                        {
                            dropAmount++;
                        }
                        Vector2 newTarg = active1.TargetPosition;
                        if (active1.ArrayLocY + dropAmount <= playAreaY)
                        { // We're falling all the way down...
                            active1.ArrayLocY = 0;
                            newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * 1; // The *1 is just for format consistency.
                        }
                        else
                        { // We're falling a now-known number of tiles.
                            active1.ArrayLocY -= dropAmount - 1;
                            newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * active1.ArrayLocY;
                        }
                        active1.TargetPosition = newTarg;
                    }
                    else
                    {
                        active1.CurMotionState = DropObject.MotionState.Still;
                        active1.RecalculatePositions(playAreaRect, playAreaX, playAreaY); // juuust in case.
                        return false;
                    }
                }

                else
                { // The tile below is clear; move the piece down one.
                    active1.ArrayLocY -= 1;
                    active1.RecalculatePositions(playAreaRect, playAreaX, playAreaY);
                }
            }
            else
            {
                active1.MotionFrameCounter--;
                if (active1.MotionFrameCounter < 0)
                {
                    active1.MotionFrameCounter = 0;
                }
                // If I want to get fancy in a later build, throw in 'smooth' position shifting. Ignoring for now.
            }
            return true;
        }

        /// <summary>
        /// Processes all motion for piece Active2. Controller inputs only change TargetPosition.
        /// This SHOULD be largely identical
        /// This also processes ArrayLocX and ArrayLocY for Active2 -  VERY important for calculating movements.
        /// Returns "true" unless the piece got marked as Still.
        /// </summary>
        public bool ProcessMotion2()
        {
            if (active2.MotionFrameCounter <= 0)
            {
                // Move the piece down by one tile, UNLESS the tile below (or active2's tile below is occupied)...
                DropObject comparator;
                if (active2.ArrayLocY > playAreaY - 1) comparator = playField[active2.ArrayLocX, playAreaY - 1];
                else if (active2.ArrayLocY == 0) comparator = playField[active2.ArrayLocX, 0]; // Won't be used, but put in as a safety.
                else comparator = playField[active2.ArrayLocX, active2.ArrayLocY - 1]; 
                
                if (active2.ArrayLocY == 0)
                { // Special case - it's on the floor of the field.
                    active2.CurMotionState = DropObject.MotionState.Still;
                    active2.RecalculatePositions(playAreaRect, playAreaX, playAreaY); // juuust in case.
                    active2.MotionFrameCounter = framesPerMotion;
                    return false;
                }
                else if (comparator != null
                    || ( playField[active1.ArrayLocX, active1.ArrayLocY-1] != null 
                    && active1.ArrayLocX != active2.ArrayLocX ) )
                { // ... In which case you set the tile to lock in, or to fall into its desired location.
                    if (comparator == null)
                    {
                        active2.CurMotionState = DropObject.MotionState.Falling;
                        int dropAmount = 1;
                        while (playField[active2.ArrayLocX, active2.ArrayLocY-dropAmount] == null && active2.ArrayLocY + dropAmount <= playAreaY)
                        {
                            dropAmount++;
                        }
                        Vector2 newTarg = active2.TargetPosition;
                        if (active2.ArrayLocY + dropAmount <= playAreaY)
                        { // We're falling all the way down...
                            active2.ArrayLocY = 0;
                            newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * 1; // The *1 is for format consistency.
                        }
                        else
                        { // We're falling a now-known number of tiles.
                            active2.ArrayLocY -= dropAmount-1;
                            newTarg.Y = playArea.Height + (playArea.Height / playAreaY) * active2.ArrayLocY;
                        }
                        active2.TargetPosition = newTarg;
                        active2.MotionFrameCounter = framesPerMotion;
                    }
                    else
                    {
                        active2.CurMotionState = DropObject.MotionState.Still;
                        active2.RecalculatePositions(playAreaRect, playAreaX, playAreaY); // juuust in case.
                        active2.MotionFrameCounter = framesPerMotion;
                        return false;
                    }
                }
                else { // Actually moves the piece down one.
                    active2.ArrayLocY -= 1;
                    active2.RecalculatePositions(playAreaRect, playAreaX, playAreaY);
                    active2.MotionFrameCounter = framesPerMotion;
                }
            }
            else
            {
                active2.MotionFrameCounter--;
                if (active2.MotionFrameCounter < 0)
                {
                    active2.MotionFrameCounter = 0;
                }
                // If I want to get fancy in a later build, throw in 'smooth' position shifting. Ignoring for now.
            }
            return true;
        }