Combinator cookbook 2.0

mmmPI · Post by **mmmPI** » Tue Dec 24, 2024 8:33 pm

Hares wrote: Tue Dec 24, 2024 7:52 pm Tried to reduce this to one combinator but didn't succeed.

I think i heard of this one called "edge detector", if i'm not mistaken, you can achieve this with a single arithmetic combinator set up to do EACH * -1 output EACH

The wiring is the trick, if you have a constant combinator representing the input value, it need to be connected to the input and the output of the arithmetic with different colors of wire, and at the output, if the signal change, during 1 tick there will be "something" , and the next tick the arithmetic combinator will again nullify everything.

Hares · Post by **Hares** » Tue Dec 24, 2024 8:43 pm

mmmPI wrote: Tue Dec 24, 2024 8:33 pm
Hares wrote: Tue Dec 24, 2024 7:52 pm Tried to reduce this to one combinator but didn't succeed.
I think i heard of this one called "edge detector", if i'm not mistaken, you can achieve this with a single arithmetic combinator set up to do EACH * -1 output EACH

The wiring is the trick, if you have a constant combinator representing the input value, it need to be connected to the input and the output of the arithmetic with different colors of wire, and at the output, if the signal change, during 1 tick there will be "something" , and the next tick the arithmetic combinator will again nullify everything.

Okay, something like this:

: 12-24-2024, 23-41-05.png (664.32 KiB) Viewed 839 times

Even though it is now reduced to 1 comb, it has very limited use case, and work well only for deterministic logical signals.
I'd prefer to stay at 2-comb design.

Khazul · Post by **Khazul** » Tue Dec 24, 2024 9:20 pm

Hares wrote: Tue Dec 24, 2024 8:43 pm
mmmPI wrote: Tue Dec 24, 2024 8:33 pm
Hares wrote: Tue Dec 24, 2024 7:52 pm Tried to reduce this to one combinator but didn't succeed.
I think i heard of this one called "edge detector", if i'm not mistaken, you can achieve this with a single arithmetic combinator set up to do EACH * -1 output EACH

The wiring is the trick, if you have a constant combinator representing the input value, it need to be connected to the input and the output of the arithmetic with different colors of wire, and at the output, if the signal change, during 1 tick there will be "something" , and the next tick the arithmetic combinator will again nullify everything.
Okay, something like this:
12-24-2024, 23-41-05.png

0eNrdmW1v2jAQx7+K5VfrlFTkiULUTprarZo0bVPpO4qQkxxgLXEyx4EhlO++S0IpZWxTokhkKBIkZ+5/51/O4ixvqBdmkEguFHU3NIDUlzxRPBbUpSMQQUrGSy5VxkI95XPBwpvqS/82IdUdAeYviOIRELUAsmQoSLgoHyQEZMwVRDd4p6+4hAkpPnHcl8BSSC+fxB2EbO0SAzX870/iSdwyQTwg6Yorf4EKKiYC5kzxJfyWTRCvhC75fKF0JmW8mpCZjIUi3hqDJyHzuZiTd+TN/eMF8eMoYRgcdRfkmrz5/HiB4alGuR+LlLrjDa1UCxSCRYAMAvB5AFJHX48LpmJJc3QQAfykrpFr+y5qnRQu2wxRd6uRJfsZ7vmb+USjIBRXHKr45cN6KrLIA4kBdhpFhooJtZ+IRpM45dXL2lDU0x3z0tHomrqDSwfDBIjar8ZtrZBQMg6nHizYkqM/OqXVePr6HhN5nqFGZzxUIA+tf5rrtjpGaPmBAzgZNIpYRuWPqjdQJu/Sm9KQFZVn5BO8kEs6LZKdsTCFvIB7wMN8iYOCoQ4h5iy5rydxCMd49PZ4HNGzdnpMYlFEgCX4d8L2oBbfF9kpDgd8B3vGZaqm/66dLc9ijRWFg+8IZabP1YAJ4buIE0Cm1Zp9i65xppKstnh+DJB9ADxkUXKMivOq7o6R8Ln0M66mIJgXQkBdJTPQduYdnQZwRrSKuUXSO6iza3p0ak7TtWUYJ15cD00W1zEE/boIjK4geN8Wgqu6CHpdQfCpLQSDmgjsYVcQjNpCMKyLYHB2VWD06jK46gqDL60xqNtv2f2uMLhvjYFZl4FzcgYHDXZbJKy6JKyuVMPH1hjYdRmcX5dk1O0U7c60SV9bY1C3VbR75/fvULdXtDrTKD22xmDQeNdknpjBXWsMho23Tadm8KEtBmav8b7JPJe1YBqNN07nUwdm453TqRnctsbAarxzOp+1YDfeOZnn0iOZTuOdk/l/9soTjRanOUWwsaEZmqkZE21cfOOFd/isWaWtsNilzUKLjTb0LQ6GUPjlBEqjIfMgRNsD42lxclMd5gSgcLIlwyXOrSTk9M2hPRw6jun0LdPI81/gPQOp

Even though it is now reduced to 1 comb, it has very limited use case, and work well only for deterministic logical signals.
I'd prefer to stay at 2-comb design.

It is still basically a 2 device setup, just arranged in a manner to allow embedding of the second differencing stage (+ve/-ve/any detect) in the second device.

mmmPI · Post by **mmmPI** » Tue Dec 24, 2024 9:41 pm

Hares wrote: Tue Dec 24, 2024 8:43 pm Okay, something like this:

Yes ! I'm using this often

Hares wrote: Tue Dec 24, 2024 8:43 pm Even though it is now reduced to 1 comb, it has very limited use case, and work well only for deterministic logical signals.
I'd prefer to stay at 2-comb design.

Well it can be used as a building block for many more advanced contraption. It is meant to detect when signal changes, and let thru the magnitude of the change be it a positive or a negative, so it can be used to trigger one time action with "if something" => then do "thing" . But it can also be used to "count" things. If you have such deviced attached to say a chest, and you pick up manually 100 things, in one single click, such edge detector will detect "-100" variation. But if you take 10 and then 10 and then 10 as an inserter does, it will detect also - 10 and -10 and - 10.

coffee-factorio · Post by **coffee-factorio** » Wed Dec 25, 2024 8:52 pm

I wanted to point out the advantages and current state of the new display panel for signage.

What you guys are doing with rs latches and timers is beautiful. I made some examples that show how that can be used in practice if you ship some combinators onto a space platform. The second latch shows how to stack on conditions - so I'm suggesting this is a "stacking latch" as a name on that basis. RS/ect. can refer to the old multi-combinator model.

The circuits shown demonstrate ammo and fuel-oxidizer safety switches for a space platform. If it can get to a port but can't raise either value after they fall under a tolerance range, it will not be able to raise a flag. This forces a platform to stay in a dock till these values are brought into a "safe flight" range. The fuel tolerance is probably looser than it ought to be.

I think that clocks are a bit more interesting now and wanted to make an example piece as to why.
This shows a clock that has been decorated with a reset condition and that passes along an enabling condition. The lamp shows that the passed signal is lost for one tick on T = 0. It also shows how time interacts with a properly set display, and signal passing over radar; which has practical applications for synchronizing remote machines to a global time.

If you revisit the old classic memory cell timers those are actually a lot of fun to play with! You can now make them cycle. And you can make a classic one-shot count up to N timer. But you can have the one shot time area reset on a control now, so you can control how each combinator works and manipulate them independently.

To demonstrate this I used a new style latch to make a reset button. It's "interesting" because you need to involve the constant combinator in the circuit. A safer design can be made by tying that circuit to a logic combinator that reads when S=1 and forwards that. It will reset the count independently of signal R, which controls if the timer can increment at all (but otherwise doesn't do anything to memory). As for the practical use of this I'm really not sure

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

Hares · Post by **Hares** » Thu Dec 26, 2024 10:30 am

For you, contributors to this topic, I'm sharing my Python script for making blueprints with text written on constant combinators.

Source code

Code: Select all

import copy
import re
import warnings
from base64 import b64decode, b64encode
from functools import reduce
from json import loads, dumps
from operator import call
from typing import *
from zlib import decompress, compress

import unicodedata

try:
    import pyperclip
except ImportError:
    pyperclip = None

# region Functools
def invcall(func, *args, **kwargs):
    """ Version of `functional.predef.call()` with inversed arguments order. """
    return call(*reversed(args), func, **kwargs)

def chain(el, *funcs: Callable):
    return reduce(invcall, funcs, el)
# endregion
# region Encoding
encode_string = lambda data: chain(data, dumps, str.encode, compress, b64encode)
decode_string = lambda data: chain(data, b64decode, decompress, loads)

def decode_blueprint(data: bytes):
    if (not data):
        raise ValueError("Cannot decode empty data")
    elif (data[0] == b'0'[0]):
        return decode_string(data[1:])
    else:
        raise ValueError(f"Unsupported blueprint format: wrong heading byte, got {data[0]!r}")

def encode_blueprint(data) -> bytes:
    return b'0' + encode_string(data)
# endregion

BLUEPRINT_TEMPLATE = b'''0eNp9UMFqwzAM/ZWhs1PWNC4ksG/oYb2VUZxU2wSxnDlKaAj598kJ29gOwxf5Penp6c1QtwN2kVigmoGawD1Ulxl6emPXJoydR6ggMeJYsib4mthJiLAYIL7hHar98mIAWUgIN4H1M1158DVGbTD/CRnoQq+zgdNG1cuKx501MOngYWd1z40iNltDYZKGxNBea3x3I6mATvUb3/+u1cmXRQOv1ArGv6hMXfI1UpRBT/42ukWQnRT5UEKvUZBD9GuTuu9cXN1X8LQCQwpRk9C3pDxI0Cv5k7CB1tWoqcJz8PhwxnvCRrW0HmaPeVmUpbW5PR7y/bJ8Ah9Wir4='''

def sanitize_text(text: str) -> str:
    slug =  unicodedata.normalize('NFD', text.lower()).encode('ascii', 'ignore')
    return re.sub(r'[^a-zA-Z\s0-9]+', ' ', slug.decode('utf-8'))

def load_template():
    container = decode_blueprint(BLUEPRINT_TEMPLATE)
    return container

def make_text_blueprint(text: str):
    container = load_template()
    bp = container['blueprint']

    bp['label'] = text
    template = bp['entities'][0]
    entity_number = 0
    bp['entities'] = list()
    for y, line in enumerate(sanitize_text(text).splitlines()):
        for x, char in enumerate(line):
            if (char.isspace()):
                continue
            else:
                entity_number += 1
            
            cc = copy.deepcopy(template)
            cc['entity_number'] = entity_number
            cc['control_behavior']['sections']['sections'][0]['filters'][0]['name'] = f'signal-{char.upper()}'
            cc['position']['x'] += x
            cc['position']['y'] += y
            bp['entities'].append(cc)
            
    
    return container

def print_text(text: str, *, copy_to_clipboard: bool = False) -> None:
    
    print(f"Preparing a blueprint for constant combinators text with text '{text}'...")
    bp = make_text_blueprint(text)
    
    print("Encoding the resulted blueprint...")
    encoded = encode_blueprint(bp).decode()
    print()
    print(encoded)
    print()
    
    if (copy_to_clipboard):
        if (pyperclip is None):
            warnings.warn(ImportWarning("Optional module pyperclip is not installed. Copy to clipboard feature can't be used"))
        else:
            print("Copying to clipboard...")
            pyperclip.copy(encoded)
    
    print("Done!")


__all__ = \
[
    'sanitize_text',
    'make_text_blueprint',
    'print_text',
]

def main():
    print_text("Hello\nworld", copy_to_clipboard=True)
    
    return 0

if (__name__ == '__main__'):
    exit_code = main()
    exit(exit_code)

Attached also as file, but should be un-renamed from .txt extension.
Usage:

Have Python installed
Edit `main` function to include the needed string (newlines supported)
Optionally -- install `pyperclip` module for instant copy-to-clipboard feature
Run

Run example

P.S.
Let me know if you want to see more of this, i.e. version that prints in display components instead of constant combinators.

dontdieych · Post by **dontdieych** » Thu Dec 26, 2024 5:13 pm

Priority map

I don't know a better title... Consider you have a list of signals and you want to map each of these signals to an associated signal. For example you want to map an item to an associated recipe. Additionally, this setup picks the item with the highest (or lowest) value, so you're able to either consume the most available item or produce more of the least available item.

It could be used as priority filter for signal to assembly machine. e.g. sending chemical plant and pipe signal to machine recipe -> pipe should have priority over chemical plant. If not, machine try to make chemical plant at first.

Tertius · Post by **Tertius** » Sat Dec 28, 2024 5:57 pm

Pulse Extender

This is one thing I didn't see yet, it's the counterpart of the edge detector: the pulse extender. It's another variation of the memory cell that simply holds the last non-null signal forever or until you reset with R <> 0.

To hold and store one specific signal and not simply everything, replace all the EACH wildcards with the specific signal you want.

: combinator_18405600_512x192.png (42.16 KiB) Viewed 640 times

The fascinating thing is the AND EACH = 0 part of the condition in the lower combinator. Usually, EACH=0 is never true, because if everything is 0 there is nothing for EACH to expand, so no check is being done, so it can never result in anything being true. But here the signals seem to have been collected by the other EACH that checks for the other wire.

So if you provide a list of non-null signals on one wire, you're able to check for EACH=0 on the other wire and get results!

Seeing all these 1- or 2-combinator setups that look all the same in the screenshot but provide meaningful different generic behaviors, I would say the 2.0 combinator changes are not just convenience, they really add generic functionality not available previously. I'm not decided yet which of all the 1-combinator examples to add to the wiki guide I intend to create, since they seem kind of trivial if you look at them. On the other hand, it's not trivial to find the right combination of wire selection, wildcard, loopback, comparison. There are so many variations possible now. People might not realize on their own some task is trivial.

Tertius · Post by **Tertius** » Sun Jan 05, 2025 7:21 pm

I found an interesting MAP on discord with just 1 decider.

This simple variant picks the most available fluid and outputs the corresponding solid fuel recipe, so always the most available fluid is converted into solid fuel.

The variant in discord additionally uses the green wire color to perform additional comparisons against configured values across wire colors, for example for "...but only if > minimum" conditions. To differ between item and recipe, the recipe values are bumped into the millions.

: 01-05-2025, 20-13-07.png (278.67 KiB) Viewed 446 times

Found here: https://discord.com/channels/1396775903 ... 7784924160

Hares · Post by **Hares** » Mon Jan 06, 2025 2:08 pm

Tertius wrote: Sun Jan 05, 2025 7:21 pm I found an interesting MAP on discord with just 1 decider.

This simple variant picks the most available fluid and outputs the corresponding solid fuel recipe, so always the most available fluid is converted into solid fuel.

Mindblowing. Instantly updated my auto-unbarelling setup to be 3 ticks faster.
This, however, works only for static maps -- for dynamic maps you still need an extra combinator or two.

: 01-06-2025, 17-06-39.png (672.64 KiB) Viewed 417 times

Amarula · Post by **Amarula** » Sat Jan 25, 2025 4:59 pm

Tertius wrote: Sun Jan 05, 2025 7:21 pm I found an interesting MAP on discord with just 1 decider.

Very cool! I used this for dynamically setting the recipe to reprocess asteroid chunks.

Factorio Forums

Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Pulse Extender

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0

Re: Combinator cookbook 2.0