sm-blueprint-lib 0.0.1__py3-none-any.whl

sm_blueprint_lib/__init__.py

@@ -0,0 +1,138 @@
+from dataclasses import asdict
+from json import load, dump, loads, dumps
+from math import ceil, log2
+
+from numpy import ndarray
+
+from sm_blueprint_lib.bases.parts.baseinteractablepart import BaseInteractablePart
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.barrierblock import BarrierBlock
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.parts.timer import Timer
+from sm_blueprint_lib.pos import Pos
+
+
+def load_blueprint(path):
+    """Load a blueprint from a path file (normally a blueprint.json).
+
+    Args:
+        path (str): The path to the json file.
+
+    Returns:
+        Blueprint: The loaded blueprint.
+    """
+    with open(path) as fp:
+        return Blueprint(**load(fp))
+
+
+def save_blueprint(path, bp: Blueprint):
+    """Save a blueprint to a file (normally a blueprint.json).
+
+    Args:
+        path (str): The path to save the json file.
+        bp (Blueprint): The blueprint to be saved.
+    """
+    with open(path, mode="w") as fp:
+        return dump(asdict(bp), fp, sort_keys=True, separators=(',', ':'))
+
+
+def load_string(str):
+    """Load a blueprint from a json string.
+
+    Args:
+        str (str): The string to be loaded.
+
+    Returns:
+        Blueprint: The loaded blueprint.
+    """
+    return Blueprint(**loads(str))
+
+
+def dump_string(bp: Blueprint):
+    """Dump a blueprint into a json-formatted string.
+
+    Args:
+        bp (Blueprint): The blueprint to be dumped.
+
+    Returns:
+        str: The json-formatted string.
+    """
+    return dumps(asdict(bp), sort_keys=True, separators=(',', ':'))
+
+
+def connect(_from, _to, *, parallel=True):
+    """Connect interactable parts together, recursively.
+
+    Args:
+        _from (Any): Must be an instance of BaseInteractablePart or a subclass.
+        Also it can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+        _to (Any): Must be an instance of BaseInteractablePart or a subclass.
+        Also it can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+        parallel (bool, optional): Defines the behaviour of the connections in the following way:
+
+        With parallel=False, everything connects to everything:
+            from1 🔀 to1
+
+            from2 🔀 to2
+
+        With parallel=True, every row is connected respectively:
+            from1 → to1
+
+            from2 → to2
+
+        Also, if the dimensions does not match it tries to adapt (many to one, one to many, etc)
+
+        Defaults to True.
+    """
+    if isinstance(_from, BaseInteractablePart) and isinstance(_to, BaseInteractablePart):
+        _from.connect(_to)
+        return
+    if parallel:    # Try connect things row-by-row if possible (one to one, one to many, many to many)
+        if not isinstance(_from, BaseInteractablePart) and not isinstance(_to, BaseInteractablePart):   # Assume both are sequence of parts
+            for subfrom, subto in zip(_from, _to):
+                connect(subfrom, subto, parallel=parallel)
+        elif not isinstance(_from, BaseInteractablePart):   # Assume _from is a sequence of parts
+            for subfrom in _from:
+                connect(subfrom, _to, parallel=parallel)
+        else:                                               # Assume _to is a sequence of parts
+            for subto in _to:
+                connect(_from, subto, parallel=parallel)
+    else:           # Just connect everything to everything lol
+        if not isinstance(_from, BaseInteractablePart) and not isinstance(_to, BaseInteractablePart):   # Assume both are sequence of parts
+            for subfrom in _from:
+                for subto in _to:
+                    connect(subfrom, subto, parallel=parallel)
+        elif not isinstance(_from, BaseInteractablePart):   # Assume _from is a sequence of parts
+            for subfrom in _from:
+                connect(subfrom, _to, parallel=parallel)
+        else:                                               # Assume _to is a sequence of parts
+            for subto in _to:
+                connect(_from, subto, parallel=parallel)
+
+
+def check_pos(pos):
+    if not isinstance(pos, Pos):
+        pos = Pos(*pos)
+    return pos
+
+
+def get_bits_required(number: int | float):
+    """Calculates how many bits are required to store this number.
+
+    Args:
+        number (int | float): The target number.
+    """
+    return ceil(log2(number))
+
+
+def num_to_bit_list(number: int, bit_length: int):
+    """Converts a number to a numpy array of its bits.
+
+    Args:
+        number (int): The number to convert.
+        bit_length (int): The number of bits the list will have.
+    """
+    output = ndarray(bit_length, dtype=bool)
+    for b in range(bit_length):
+        output[b] = bool((number >> b) & 1)
+    return output

sm_blueprint_lib/bases/controllers/basecontroller.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from sm_blueprint_lib.constants import get_new_id
+from sm_blueprint_lib.id import ID
+
+
+@dataclass
+class BaseController:
+    """Base class for controller objects (used in interactable parts and so)
+    """
+    controllers: Optional[list[ID]] = field(kw_only=True, default=None)
+    id: int = field(kw_only=True, default_factory=get_new_id)
+    joints: Optional[list[ID]] = field(kw_only=True, default=None)
+
+    def __post_init__(self):
+        try:
+            self.controllers = [ID(**c) for c in self.controllers]
+        except TypeError:
+            pass

sm_blueprint_lib/bases/controllers/baselogiccontroller.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.basecontroller import BaseController
+
+
+@dataclass
+class BaseLogicController(BaseController):
+    """Base class for Logic parts' Controllers (mostly Logic Gate and Timer)
+    """
+    active: bool = field(kw_only=True, default=False)

sm_blueprint_lib/bases/controllers/logicgatecontroller.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.baselogiccontroller import BaseLogicController
+
+
+@dataclass
+class LogicGateController(BaseLogicController):
+    """Logic Gate's Controller
+    """
+    mode: int = 0

sm_blueprint_lib/bases/controllers/sensorcontroller.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.basecontroller import BaseController
+
+
+@dataclass
+class SensorController(BaseController):
+    """Sensor's Controller
+    """
+    audioEnable: bool
+    buttonMode: bool
+    color: str
+    colorMode: bool
+    range: int
+
+    def __post_init__(self):
+        super().__post_init__()
+        # if color given as (r, g, b) then convert to hex string
+        if not isinstance(self.color, str):
+            self.color = "%02X%02X%02X" % (
+                self.color[0], self.color[1], self.color[2])
+        self.audioEnable = bool(self.audioEnable)
+        self.buttonMode = bool(self.buttonMode)
+        self.colorMode = bool(self.colorMode)

sm_blueprint_lib/bases/controllers/timercontroller.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.controllers.baselogiccontroller import BaseLogicController
+
+
+@dataclass
+class TimerController(BaseLogicController):
+    """Timer's Controller
+    """
+    seconds: int
+    ticks: int

sm_blueprint_lib/blueprint.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.parts.basepart import BasePart
+from sm_blueprint_lib.body import Body
+from sm_blueprint_lib.constants import VERSION
+
+
+@dataclass
+class Blueprint:
+    bodies: list[Body] = field(default_factory=lambda: [Body()])
+    version: int = VERSION.BLUEPRINT_VERSION
+
+    def __post_init__(self):
+        try:
+            self.bodies = [Body(**body) for body in self.bodies]
+        except TypeError:
+            pass
+
+    def add(self, *obj, body=0):
+        """Adds the object(s) to the blueprint.
+
+        Args:
+            obj (Any): Can be a instance of BasePart or a subclass. It also can be any nested iterable of instances (list of parts, list of lists of parts, etc).
+            body (int, optional): Specify in which blueprint's body the object will be placed. Defaults to 0.
+        """
+        for subobj in obj:
+            if isinstance(subobj, BasePart):
+                self.bodies[body].childs.append(subobj)
+            else:
+                for subsubobj in subobj:
+                    self.add(subsubobj, body=body)

sm_blueprint_lib/body.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass, field
+
+from sm_blueprint_lib.bases.parts.basepart import BasePart
+from sm_blueprint_lib.constants import SHAPEID
+
+
+@dataclass
+class Body:
+    childs: list[BasePart] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.childs = [SHAPEID.SHAPEID_TO_CLASS[child["shapeId"]](**child)
+                       for child in self.childs]

sm_blueprint_lib/bounds.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Bounds:
+    """Class that represents the bounds of a boundable block (x, y, z)
+    """
+    x: int
+    y: int
+    z: int

sm_blueprint_lib/constants.py

@@ -0,0 +1,29 @@
+class SHAPEID:
+    BARRIER_BLOCK = "09ca2713-28ee-4119-9622-e85490034758"
+    LOGIC_GATE = "9f0f56e8-2c31-4d83-996c-d00a9b296c3f"
+    TIMER = "8f7fd0e7-c46e-4944-a414-7ce2437bb30f"
+    SENSOR5 = "20dcd41c-0a11-4668-9b00-97f278ce21af"
+    SWITCH = "7cf717d7-d167-4f2d-a6e7-6b2c70aa3986"
+    SHAPEID_TO_CLASS = {}
+
+
+class AXIS:
+    DEFAULT_XAXIS = 1
+    DEFAULT_ZAXIS = 3
+
+
+class VERSION:
+    BLUEPRINT_VERSION = 4
+
+
+TICKS_PER_SECOND = 40
+
+__global_id_counter = 0
+"""Atempting to modify this global variable may cause to break your blueprints lol.
+"""
+
+
+def get_new_id():
+    global __global_id_counter
+    __global_id_counter = (new_id := __global_id_counter) + 1
+    return new_id

sm_blueprint_lib/id.py

@@ -0,0 +1,5 @@
+from dataclasses import dataclass
+
+@dataclass
+class ID:
+    id: int

sm_blueprint_lib/pos.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Sequence
+
+
+@dataclass
+class Pos:
+    """Class that represents the position of a block (x, y, z)
+    """
+    x: int
+    y: int
+    z: int
+
+    def __add__(self, o: "Pos" | Sequence):
+        if isinstance(o, Pos):
+            return Pos(self.x + o.x, self.y + o.y, self.z + o.z)
+        return Pos(self.x + o[0], self.y + o[1], self.z + o[2])

sm_blueprint_lib/prebuilds/adder.py

@@ -0,0 +1,44 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import get_bits_required, check_pos, connect, num_to_bit_list
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def simple_adder_subtractor(bp: Blueprint,
+                            bit_length: int,
+                            pos: Pos | Sequence = (0, 0, 0)):
+    pos = check_pos(pos)
+    input_a = [LogicGate(pos+(x, 0, 2), "FF0000", 1)
+               for x in range(bit_length)]
+    input_b = [LogicGate(pos+(x, 0, 0), "FF0000", 2)
+               for x in range(bit_length)]
+    and_0 = [LogicGate(pos+(x, -1, 2), "000000", 0)
+             for x in range(bit_length)]
+    xor_0 = [LogicGate(pos+(x, -1, 0), "000000", 2)
+             for x in range(bit_length)]
+    or_0 = [LogicGate(pos+((x, -2, 0) if x + 1 != bit_length else (x+1, -2, 2)), "000000" if x + 1 != bit_length else "0000FF", 1)
+            for x in range(bit_length)]
+    and_1 = [LogicGate(pos+(x, -2, 1), "000000", 0)
+             for x in range(bit_length)]
+    xor_1 = [LogicGate(pos+(x, -2, 2), "0000FF", 2)
+             for x in range(bit_length)]
+    carry_in = LogicGate(pos+(-1, -2, 0), "FF0000", 1)
+
+    connect(input_a, and_0)
+    connect(input_a, xor_0)
+    connect(input_b, and_0)
+    connect(input_b, xor_0)
+    connect(and_0, or_0)
+    connect(xor_0, and_1)
+    connect(xor_0, xor_1)
+    connect(and_1, or_0)
+    connect(or_0, and_1[1:])
+    connect(or_0, xor_1[1:])
+    connect(carry_in, and_1[0])
+    connect(carry_in, xor_1[0])
+    connect(carry_in, input_b)
+
+    bp.add(input_a, input_b, and_0, xor_0, or_0, and_1, xor_1, carry_in)
+    return input_a, input_b, and_0, xor_0, or_0, and_1, xor_1, carry_in

sm_blueprint_lib/prebuilds/barrel_shifter.py

@@ -0,0 +1,86 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import get_bits_required, check_pos, connect, num_to_bit_list
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def barrel_shifter(bp: Blueprint, bit_length: int, num_bit_shift: int, pos: Pos | Sequence = (0, 0, 0)):
+    pos = check_pos(pos)
+    inputs = [LogicGate(pos + (x, 0, 0), "FF0000", 1)
+              for x in range(bit_length)]
+    inputs_shift_binary = ndarray((num_bit_shift, 2), dtype=LogicGate)
+    # always_off = LogicGate(pos + (-1, -1, 0), "000000")
+
+    for x in range(num_bit_shift):
+        inputs_shift_binary[x, :] = [
+            LogicGate(pos + (x-num_bit_shift, -1, 0), "FF0000", 4),
+            LogicGate(pos + (x-num_bit_shift, 0, 0), "FF0000", 1),
+        ]
+
+    arr = [
+        [
+            [LogicGate(pos+(x, (-y-1), 0), "000000")
+             for x in range(bit_length + (2**y - 1 if y != num_bit_shift - 1 else 0))]
+            for y in range(num_bit_shift)
+        ],
+        [
+            [LogicGate(pos+((x - (2**y if y == num_bit_shift-1 else 0)), (-y-1), 1), "000000")
+             for x in range(2**y, bit_length + 2**(y+1) - 1 - (2**y if y == num_bit_shift-1 else 0))]
+            for y in range(num_bit_shift)
+        ],
+        [
+            [LogicGate(pos+(x, (-y-1), 2), "000000" if y != num_bit_shift - 1 else "0000FF", 1)
+             for x in range(bit_length - 1 + (2**(y+1) if y != num_bit_shift-1 else 1))]
+            for y in range(num_bit_shift)
+        ],
+    ]
+
+    connect(inputs, arr[0][0])
+    connect(inputs, arr[1][0])
+    for y in range(num_bit_shift):
+        connect(arr[0][y], arr[2][y])
+    for y in range(num_bit_shift-1):
+        connect(arr[2][y], arr[0][y+1])
+        connect(arr[1][y], arr[2][y][2**y:])
+    for y in range(num_bit_shift-2):
+        connect(arr[2][y], arr[1][y+1])
+    connect(arr[2][-2][2**(num_bit_shift-1):], arr[1][-1])
+    connect(arr[1][-1], arr[2][-1])
+    for y in range(num_bit_shift):
+        connect(inputs_shift_binary[y, 0], arr[0][y])
+        connect(inputs_shift_binary[y, 1], arr[1][y])
+
+    bp.add(inputs, inputs_shift_binary, arr)
+    # arr = ndarray((bit_length, num_bit_shift, 3), dtype=LogicGate)
+    # for x in range(num_bit_shift):
+    #     inputs_shift_binary[x, :] = [
+    #         LogicGate(pos + (x+bit_length+1, -1, 0), "FF0000", 4),
+    #         LogicGate(pos + (x+bit_length+1, 0, 0), "FF0000", 1),
+    #     ]
+    # for x in range(bit_length):
+    #     for y in range(num_bit_shift):
+    #         arr[x, y, :] = [
+    #             LogicGate(pos + (x, -y-1, 0), "000000"),
+    #             LogicGate(pos + (x, -y-1, 1), "000000"),
+    #             LogicGate(pos + (x, -y-1, 2), "000000"
+    #                       if y + 1 < num_bit_shift else "0000FF", 1),
+    #         ]
+    # always_off.connect(always_off)
+
+    # connect(inputs, arr[:, 0, 0])
+    # connect(inputs, arr[1:, 0, 1])
+    # connect(arr[:, :, 0], arr[:, :, 2])
+    # connect(arr[:, :, 1], arr[:, :, 2])
+    # connect(arr[:, :, 2], arr[:, 1:, 0])
+    # for y in range(num_bit_shift):
+    #     if y + 1 < num_bit_shift:
+    #         connect(arr[:, y, 2], arr[2**(y+1):, y+1, 1])
+    #     connect(always_off, arr[:2**y, y, 1])
+    #     connect(inputs_shift_binary[y, 0], arr[:, y, 0])
+    #     connect(inputs_shift_binary[y, 1], arr[:, y, 1])
+
+    # bp.add(inputs, inputs_shift_binary, arr, always_off)
+
+    # return inputs, inputs_shift_binary, arr, always_off

sm_blueprint_lib/prebuilds/clock40hz.py

@@ -0,0 +1,28 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import get_bits_required, check_pos, connect, num_to_bit_list
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def clock40hz(bp: Blueprint, bit_length: int, pos: Pos | Sequence = (0, 0, 0)):
+    pos = check_pos(pos)
+
+    arr = ndarray((bit_length, 2), dtype=LogicGate)
+    for x in range(bit_length):
+        arr[x, :] = [
+            LogicGate(pos + (x, 0, 0), "0000FF", 2 if x else 4),
+            LogicGate(pos + (x, 1, 0), "000000", 0),
+        ]
+
+    connect(arr[:, 0], arr[:, 0])
+    connect(arr[1:, 1], arr[1:, 0])
+    connect(arr[0, 0], arr[0, 1])
+    connect(arr[0, 1], arr[1:, 1])
+    for x in range(1, bit_length):
+        connect(arr[x, 0], arr[x+1:, 1])
+
+    bp.add(arr)
+
+    return arr

sm_blueprint_lib/prebuilds/comparator.py

@@ -0,0 +1,70 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import check_pos, connect
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def comparator(bp: Blueprint,
+               bit_length: int,
+               pos: Pos | Sequence = (0, 0, 0)):
+    pos = check_pos(pos)
+    inputs = ndarray((bit_length, 4), dtype=LogicGate)
+    ands_2 = ndarray((bit_length, 2), dtype=LogicGate)
+    nors_3 = ndarray(bit_length, dtype=LogicGate)
+    ands_4 = ndarray(2 * (bit_length - 1) + 1, dtype=LogicGate)
+    ors_5 = ndarray(2, dtype=LogicGate)
+    inputs[:, 0] = [
+        LogicGate(pos+(x, -1, 0), "FF0000", 4)
+        for x in range(bit_length)
+    ]
+    inputs[:, 1] = [
+        LogicGate(pos+(x, 0, 0), "FF0000", 1)
+        for x in range(bit_length)
+    ]
+    inputs[:, 2] = [
+        LogicGate(pos+(x, -1, 2), "FF0000", 4)
+        for x in range(bit_length)
+    ]
+    inputs[:, 3] = [
+        LogicGate(pos+(x, 0, 2), "FF0000", 1)
+        for x in range(bit_length)
+    ]
+    for x in range(bit_length):
+        ands_2[x, :] = [
+            LogicGate(pos+(x, -2, 0), "000000"),
+            LogicGate(pos+(x, -2, 1), "000000"),
+        ]
+        nors_3[x] = LogicGate(pos+(x, -2, 2), "000000", 4)
+
+    for n in range(2 * (bit_length - 1) + 1):
+        if n == 0:
+            ands_4[n] = LogicGate(pos+(1, -4, 0), "0000FF")
+        else:
+            ands_4[n] = LogicGate(pos+((n-1)//2, -3, (n-1) % 2), "000000")
+
+    ors_5[:] = [
+        LogicGate(pos+(0, -4, 0), "0000FF", 1),
+        LogicGate(pos+(2, -4, 0), "0000FF", 1),
+    ]
+
+    connect(inputs[:, 0], ands_2[:, 1])
+    connect(inputs[:, 1], ands_2[:, 0])
+    connect(inputs[:, 2], ands_2[:, 0])
+    connect(inputs[:, 3], ands_2[:, 1])
+
+    connect(ands_2, nors_3)
+
+    connect(ands_2.flat, ands_4[1:])
+    for x in range(bit_length):
+        connect(nors_3[x], ands_4[:2*x+1])
+
+    connect(ands_4[1::2], ors_5[0])
+    connect(ands_4[2::2], ors_5[1])
+    connect(ands_2[-1, 0], ors_5[0])
+    connect(ands_2[-1, 1], ors_5[1])
+
+    bp.add(inputs, ands_2, nors_3, ands_4, ors_5)
+
+    return inputs, ands_2, nors_3, ands_4, ors_5

sm_blueprint_lib/prebuilds/counter.py

@@ -0,0 +1,68 @@
+from typing import Sequence
+from numpy import ndarray
+from sm_blueprint_lib import get_bits_required, check_pos, connect, num_to_bit_list
+from sm_blueprint_lib.blueprint import Blueprint
+from sm_blueprint_lib.parts.logicgate import LogicGate
+from sm_blueprint_lib.pos import Pos
+
+
+def counter(bp: Blueprint,
+            bit_length: int,
+            pos: Pos | Sequence = (0, 0, 0),
+            precreated_swxors=None, precreated_ands=None, precreated_count=None):
+    pos = check_pos(pos)
+    arr = ndarray((bit_length, 2), dtype=LogicGate)
+    count = precreated_count if precreated_count is not None else LogicGate(
+        pos + (-1, 1, 0), "FF0000", 1)
+    for x in range(bit_length):
+        arr[x, :] = [
+            precreated_swxors[x] if precreated_swxors is not None else LogicGate(
+                pos + (x, 0, 0), "0000FF", 2),
+            precreated_ands[x] if precreated_ands is not None else LogicGate(
+                pos + (x, 1, 0), "000000"),
+        ]
+    if precreated_swxors is None:
+        connect(arr[:, 0], arr[:, 0])
+    connect(arr[:, 1], arr[:, 0])
+    for x in range(bit_length):
+        connect(arr[x, 0], arr[x+1:, 1])
+    connect(count, arr[:, 1])
+
+    if precreated_swxors is None:
+        bp.add(arr[:, 0])
+    if precreated_ands is None:
+        bp.add(arr[:, 1])
+    if precreated_count is None:
+        bp.add(count)
+    return arr, count
+
+
+def counter_decrement(bp: Blueprint,
+                      bit_length: int,
+                      pos: Pos | Sequence = (0, 0, 0),
+                      precreated_swxors=None, precreated_nors=None, precreated_count_nor=None):
+    pos = check_pos(pos)
+    arr = ndarray((bit_length, 2), dtype=LogicGate)
+    count = precreated_count_nor if precreated_count_nor is not None else LogicGate(
+        pos + (-1, 1, 0), "FF0000", 4)
+    for x in range(bit_length):
+        arr[x, :] = [
+            precreated_swxors[x] if precreated_swxors is not None else LogicGate(
+                pos + (x, 0, 0), "0000FF", 2),
+            precreated_nors[x] if precreated_nors is not None else LogicGate(
+                pos + (x, 1, 0), "000000", 4),
+        ]
+    if precreated_swxors is None:
+        connect(arr[:, 0], arr[:, 0])
+    connect(arr[:, 1], arr[:, 0])
+    for x in range(bit_length):
+        connect(arr[x, 0], arr[x+1:, 1])
+    connect(count, arr[:, 1])
+
+    if precreated_swxors is None:
+        bp.add(arr[:, 0])
+    if precreated_nors is None:
+        bp.add(arr[:, 1])
+    if precreated_count_nor is None:
+        bp.add(count)
+    return arr, count