Official Factorio Wiki - User contributions [en]

Tutorial:Combinator tutorial

2024-08-28T19:26:50Z

Ndh:

''This is an '''advanced''' tutorial. Beginners should refer to the [[Tutorial:Circuit network cookbook]] for examples and the [[Circuit network]] page for an overview over the circuit network. This tutorial assumes a basic understanding of circuits and covers more advanced topics like SR latches, memory cells and clocks.''

{{Languages}}
== Introduction ==
Combinator logic is achieved by cross-connecting outputs to inputs in such a way to achieve the desired logic. While advanced logic requires a multitude of combinators, some very useful basic logic can be achieved using only a handful of combinators. Combinator logic works because Factorio only updates at '''60 times per second'''. Logically, each update tick is separated into two steps. In the first step, all combinators first read the input from the connected network(s), perform their computations. This produces an output value for every combinator. The tick update concludes with the second step, where the values of each network will be updated as the sum of all connected values.

When logic values are computed by combinators, the outputs are not recognized by the circuit network until the following step. So when a [[decider combinator]] is used to detect a certain input condition, its output value will not take effect on the circuit network until the next step. '''This behavior is important to remember and can result in sequencing errors and significant delays when multiple combinators are connected in series.'''

Circuit wires act like a wire bus in electronics; they carry information in the connected wires, meaning that if there are similar signals on a wire it will add them automatically. If the signal is different, it will be carried in that wire as well, but as a different signal.

When cross-connecting combinators, it is good practice to use the unused color to cross-connect, this will split the input and output networks and prevent unwanted inputs from accidentally connecting to a larger circuit network. Combinators will sum the red and green inputs prior to calculation, so either color can be used when wiring the output back to the input. In most cases however, it is more useful to use the opposing color of the wire so that it will not interfere with the resulting output and input.

When trying to understand combinators, your best friend is the in-game editor. You can pause the game and, with the "Tick once" keybinding, inspect nodes and networks as they go through different states.

== Virtual signals ==

[[File:Virtual Signals dialog box.png|thumb|right|Virtual Signals available for use in the circuit network]]

In addition to the standard item signals, Factorio's circuit network also includes a set of signals that do not represent any particular game item. Instead, these virtual signals serve as user-definable channels for the circuit network; they hold whatever meaning the user wants them to. There are currently 48 virtual signals that can be sent over the circuit network:

* The 36 alphanumeric characters (A-Z, 0-9)
* Nine colors: red, green, blue, yellow, magenta, cyan, white, grey, and black
* Three icons: a check mark, an informational letter 'i', and a small, white dot

=== Logic signals ===

There are three additional virtual signals known as ''logic signals''. Unlike other signals, they cannot be sent over the circuit network; instead, they apply additional logic to combinators that modify their behavior. Specifically, these logic symbols act as wildcards, which are special signals that represent '''zero or more''' arbitrary signals instead of representing a single discrete signal. Factorio's circuit network implements three types of wildcards.

==== <span style="color:#FF6666">Everything wildcard</span> [[File:Signal_everything.png|left|20px]] ====

The ''Everything'' wildcard is used with decider combinators. Its exact behavior depends on whether it is used as an input or an output:
* '''Input''': Returns true if ''all'' input signals pass the condition, or if there are ''no'' input signals, otherwise it returns false.
* '''Output''': Returns ''all'' non-zero input signals.

When used as an input, the ''everything'' wildcard can be thought of as a logical AND, or a [[:Wikipedia:universal quantification|universal quantifier]]. When used as an output, it acts as an 'echo' or 'dump' of input signals.

'''Note''': Can be used as an output as long as the input is not an ''each'' wildcard.

==== <span style="color:#99FF99">Anything wildcard</span> [[File:Signal_anything.png|left|20px]] ====

The ''Anything'' wildcard is also used with decider combinators.

Given '''at least one''' input signal, it returns true if ''any'' input signal passes the condition. If no signal passes the condition, or there are no input signals, then it returns false. From this behavior, the ''anything'' wildcard can be thought of as a logical OR, or an [[:Wikipedia:existential quantification|existential quantifier]].

When used in both the input and output of a decider combinator, ''anything'' will return one of the signals that matched.

==== <span style="color:#FFFF99">Each wildcard</span> [[File:Signal_each.png|left|20px]] ====

The ''Each'' wildcard is used with both decider combinators and [[arithmetic combinator]]s, and behaves somewhat uniquely compared to the previous two. Generally speaking, it performs a combinator action on each signal '''individually''', with the exact action depending on how it is used, and the type of combinator it is used in. It can be used as an input, and it can be used as an output, but ''only when it is used as input as well''.

In a '''decider combinator''', when used as an input, the ''each'' wildcard individually compares each input signal against the combinator condition, returning each signal that passes the condition. The manner that the ''each'' wildcard returns signals when used as input depends on whether or not it is also used as output:
* '''Input only''': Sums each input signal that passed the condition, and depending on output settings returns either a count of the passed signals or a summation of their values as the desired output signal.
* '''Input and Output''': Returns each signal that passed the condition, their values depending on the output settings.

In an '''arithmetic combinator''', the designated arithmetic operation is applied individually to each input signal, and similar to the decider combinator, the signal that is returned depends on whether or not the ''each'' wildcard is used as output:
* '''Input only''': The result of each operation on the input signals is summed and returned as the desired output signal.
* '''Input and Output''': Each input signal is returned with the result of the specified operation applied to it.

The ''Each'' wildcard is therefore notably more complex than the other two wildcards, but offers a good deal of power in exchange for its complexity.

== Input insulator & gate ==
An arithmetic combinator set to (In: Each + 0, Out: Each) can be used to swap wire colors and as an insulator to prevent downstream logic from backfeeding into the circuit network's inputs.

A decider combinator set to (Out: Everything, Input-> Output) will also function as an insulator as long as the set logic condition is true. This can also selectively pass or 'gate' inputs only when desired. This could be used to sequentially poll remote train stations for their chest contents, and include only desired stations.

== Set/Reset latching switch ==
You want something to SET a trigger at some quantity, but then STAY on until that quantity hits some other value, the RESET value. You'll need one decider combinator and one arithmetic combinator. (Two decider combinators and a [[constant combinator]] can also be used for more complex multi-channel conditions.)

Setup the first decider combinator to the desired set conditional and to output a 1. Then connect the output to the input of an arithmetic combinator, and configure it to multiply by the bias value, which is the difference between the set and reset values, and wire the arithmetic output to the input of the decider. The arithmetic output channel must be set the same as the decider's input channel.<br>
Whenever the set conditional is reached, the decider will output a '1', and the bias of the arithmetic combinator will be applied. This will 'hold' the output true until the value goes back below the reset point.

In this specific example, the pump runs when light oil reaches 20000, and turns off when it reaches 5000:

[[File:SR_latch.png|600px]]

A similar backup steam power example with detailed configuration and explanation can be found here:<br>[[Tutorial:Circuit_network_cookbook#RS_latch_-_single_decider_version|RS latch - single decider version]]

== Basic memory ==
A decider combinator can be used to store values, either for a counter or for more advanced logic (see below). The decider combinator is configured with
* input and output connected to the same network (typically each other),
* condition set to a signal > 0 for positive values or ≠ 0 to store both positive and negative values,
* output set to the input count of a specific input signal or [*].
As long as all inputs on the network are zero, it will hold the previously set value.

Remember the two step update process from above? If the network has value [X]=5, the combinator will read this value from the network as its input, determine that it is > 0. It will then set the output to the input, which is [X]=5. In the next step, the value of the network will be computed, which is the sum of all the connected outputs, which is [X]=5, again.

A non-zero input held over time, e. g. the output of a constant combinator, will create a basic runaway clock. The stored value will be incremented by the sum of all connected input values every cycle. So e. g. with a constant combinator that produces [A]=1 connected to the memory, the network will store the value 1 in the first tick, 2 in the second, etc., incrementing 60 times per second.
{{BlueprintString|bp-string=0eNqlU11rwzAM/C96TkuStWvqh8F+xyghH2orSOygyGWh5L/PjkcJJetW9hKQLd2d7pwrlI3FjkkLqCtQZXQP6uMKPZ100fgzGToEBSTYQgS6aH1VY0U18qoybUm6EMMwRkC6xk9QyRj9CuCJpNCyjJCOhwhQCwlh0DMVQ65tWyI7iodAEXSmd7NGe36Ht9sk620EA6jVNsvWW8fk5oRNk5d4Li7khlznkRpB/sGAC7FYd3JjDh2rd5jQrHcwiWcmHAKLxsor6T1U4j8nRtTzpah2G7te4sqSTKWfHr2Nd3unjxJYWPtu6Zo4qAmECxZ8w+burqab7iNxL/mfLcEL8iBn0qfgTUgIVOyLtit4kqvgzU0aK539B3Y35JP5+ZFNm5N2YKCELY7P2J/MvF6II53CTJ9Lzz3h6c2r2T8WgZPfhwCyZLPbp7vsdR+/xJtx/AJNbzZ8}}

Again, how does this work in detail? The network will start without any values set. As soon as the constant combinator becomes active, it will produce [A]=1, and the decider combinator will produce 0 because no value is set yet. Step 2: The network will be set to the sum of all output, so [A]=1. In the next update tick, the constant combinator produces [A]=1 again, but now the decider sees [A]=1, so it would also output [A]=1. Step 2: The network is set to the sum, which is [A]=2. And so on.

Typically a constant combinator producing 1 will be used, but of course it could output other values, including negative values.
A negative values would decrease the stored value in the example below.
If the decider combinator uses > 0 as the condition, only positive values will be allowed, so the value will stop decreasing if 0 is reached.
If the condition is ≠ 0, negative values will also be allowed.

A single pulse of an input will cause a single increment by the pulsed value, creating a counter. In the following blueprint, place one item on the belt. Every time it is scanned by the connected belt, a pulse is generated that increments the stored value.
{{BlueprintString|bp-string=0eNqllMGO4jAMQP/F5zAqpaXQw/7IahWljQFLbVIlLtoK5d83aXdZEJ3DMBeQU+fFenZyg6YbcXBkGOobUGuNh/rnDTydjerSGk8DQg3E2IMAo/oUsVPGD9bxpsGOIQggo/E31NvwSwAaJiZcSHMwSTP2DbqY8BlDwGB93GZNOjWiqqL8KAVMUG/KQ/ZRhiBeaPl7tG2kCdDksF1S8hX27gvs/XOlT+xCQNTKznaywYu6knVpX0uuHYklGtV0KDX59A/1SXUexf2zQ6XlRRktEySWGK2yGx8y/q0vqb3VEZKF+VCz1ODTedv0c3aI5rEtpKEu/7NSGFsY1lwX7/l4cV2ssMs7W2NLGt2mtX1DRnGUtcI/fmo7X7f9F5tkabo7OZHzLF9m/UqOx7hyL2rJ2OAV3cQXMmdY/HpW6eJkKegH5eZya/gRd9qRh/Eb7GGKtY6G5cnZXpKJsKXx4Sut3T24Xml1HlstIP/uZOzfuoXVcf1OV2/N2Ux7moR9eormZ6t+eOUERNF+GZXDtqiOeXXYH7NdVoTwB9igtjA=}}

A stored value is cleared if the condition is no longer met, which makes the decider clear its output. This only works if the value is also not output elsewhere in the network. A stored value can also be reset to zero if a negative pulse equal to the input occurs. The latter can also happen while other inputs are still connected.

== Basic clocks ==
[[File:Timer.png|thumb|right|377px|A basic clock. 30 ticks is the ceiling for Signal 1; which is continuously added.]]
Clocks are constructed by having the output of a combinator tied back to its own input, such that every cycle advances its own count. Either the arithmetic combinator or the decider combinator can be used.

An arithmetic combinator tied to itself is fun to watch and will happily run-away, but requires additional control logic to reset.

With a single decider combinator, a self-resetting clock can be built. Wire output to input and configure with Less Than (<) with a specific number, and Input -> Output. When a constant combinator is then connected to the input, every cycle it will count up by the output of the constant combinator until the number is reached. The decider will then clear its output, only the constant combinator will contribute to the value in the network, which resets the clock.

This means that the clock sequence will not include zero. It will begin at the value set in the constant combinator. Furthermore, it will include the number value that causes the conditional to become false. An arithmetic combinator can modify the clock sequence, but remember that its outputs will occur one cycle later than the clock cycle values.

A clock that only counts once can be built using the following setup. The clock can get reset by enabling and disabling the constant combinator that outputs [R].

[[File:Onetime_Clock.png|thumb|none|360px|One-time clock. Runs until T=Z+1. Reset via R>0.]]
{{BlueprintString|bp-string=0eNq1VdtugzAM/Rc/p1Wh9BZtPzHtaVOFKLidJUhQSKpVFf8+B6oK9QrT9oJI4hzb5xzDETa5w9KQsiCPQKlWFcjPI1S0U0nu9+yhRJBAFgsQoJLCrzJMKUMzSnWxIZVYbaAWQCrDb5BBLZ4C+EQ2UfY2QlivBaCyZAnbeprFIVau2KDhFI8qEVDqiq9q5dMz3GI2E3AAOZqtgvGM02RkMG0D5sLXYo3O4w1+JXtiAL51go35LGugKr+7JVPZ+Kq1PRnreOdcVBsxevctVegx+l/68Je4mzIxTTcSXjhGO1u6oalTXR64A6dsvDW6iEkxBshtkldYN+dKtTw03QX+YTDrEk68ijiSTOrINstGnJ1BVJeBfMKoYT+YgINr75QLacOHHrmh7WI8WN0t5RbNHac/Ecb5UQmWk47d13e4vElS0I+G6VAawjMNy9V/0vDWpaFLAr9Xsc/W+msAJT2dEf1y6K/5CP9x6E/8tJqBnFwM8+sfD7M1bsgsB31nedoR4PZH4MGoX3tcDFDeO8n/LGTn5yRgz05txVsG0WIVLpbz1WQ6ier6B+n0TYg=}}

== Pulse generators ==

Connecting an additional (=) decider combinator to the output of a basic clock will create a pulse generator, and will pulse a single output every time the clock cycles through the set condition. Any output value can be used, either directly from the clock sequence (input->output), a 1, or some value on a separate logic channel on the circuit network, such as set by a constant combinator. or by the circuit network.<br />
[[File:PulseGen.png|500px]]
*''The value 1 can be written as any positive integer, so long as it is within the cap or ceiling of your timer.''
*''As an example from the above timer, this light will pulse every 1st tick after the timer reaches 30 ticks, making it pulse 1/30th of a second, as Factorio updates at 60 times per second.''

== Edge detectors ==

The computation delay of combinators can be used to generate a one-tick pulse when a signal changes, e. g. from 0 to 1.

Connect an output of a combinator with red to the input, and with green to the output of an arithmetic combinator that multiplies by -1. When the red circuit changes a signal from 0 to 1, the arco gets input 1, but the output is still 0. So the green circuit has value 1 for this one tick. In the next tick, the arco is updates, so the output switches to -1. The green circuit now has two inputs that cancel each other out. The same happens if the red input signal changes from 1 to 0, but in this case the green circuit becomes -1 for one tick.

If you're only interested in generating a pulse if the signal changes from 0 to 1, a decider combinator set to >0 can be used to filter out the negative pulses. This mechanic can e. g. be used to count the numbers of trains that enter a station.

== Counter ==
A counter is used to count the number of input events, and output the sum of that count. Any pulsing input into a decider combinator configured input -> output and wired between output and input will create a counter, but this input must be zero at all other times or else the combinator will run away like a clock. A pulse generator is normally used to accomplish this. Combining several gating decider isolators set with sequential conditionals, a clock, and a pulse generator to the input of a counter will allow remote polling and counting of each isolator's contents.

== Memory cells ==

=== Simple latch ===

When looping the combinator to itself, use a different color of wire from your main inputs or outputs.

[[File:SimpleLatchv2.png|415px]]

Truth Table:

{| class="wikitable"
|-
!Output 1!!Input 1!!Input 2!! Output 1 (t+1)
|-
| 0 || 0 || 0 || 0
|-
| 0 || 1 || 0 || 1
|-
| 0 || 0 || 1 || 0
|-
| 0 || 1 || 1 || 0
|-
| 1 || 0 || 0 || 1
|-
| 1 || 1 || 0 || 1 ''(2)''
|-
| 1 || 0 || 1 || 0
|-
| 1 || 1 || 1 || 1 ''(2)''
|-
|}
''Output 1 is the green wire loop seen in the picture, it carries the value to latch.''

''Input 1 is Set, while Input 2 is Reset.''

=== Positive cell ===

Cell for storing a positive value, with reset support:

[[File:AdvancedMemoryCell.png|500px]]

Connect the desired value as signal I on the right side to set the memory cell and connect a negative value as signal I to reset the cell.

* The output of the memory cell is 2 mutually exclusive signals.
** In case input signal I > 0 then signal I is passed to the other side.
** In case input signal I is interrupted, then signal M is passed instead as a memory of previous input value.
* When input signal I is interrupted, it takes 2 ticks to switch to memory signal M.
* In case input I signal lasts only one tick then memory cell starts to cycle between the 2 previous values, tick by tick. Indefinitely.
* Switching is seamless, e.g. there are no ticks with empty signal.

=== Positives and negatives cell ===

This cell can store negatives or positives. Reset is done on a dedicated line. Additionally, a 1-tick burst is handled properly. [https://forums.factorio.com/viewtopic.php?f=193&t=60330&p=362377#p362377 Forum post].

* The output M (memory) is the last non-zero input I (Input).
* A non zero R (reset) signal sets the output to zero.
* 1-tick bursts of R or I are handled properly.
* Negatives are handled properly.

[[File:Memory_cell_with_negatives.png|500px]]

== Multiplier and Dictionaries/Arrays ==
[[File:combinatorMultiplierDetailed.png|left|500px]]
* Multiplying two signals together is simple and requires only a single combinator, however multiplying a set of signals is more complicated.
* A proof is shown below for the equation and why it works.
* A dictionary is a system that allows a value on a specific signal to be accessed. For example, A can contain many signals (either from a constant combinator or memory cell) and B can contain 1 of a specific signal (such as blue signal). What remains is the blue-signal value from A. This is because all the other signals are multiplied by 0.
* Arrays are similar to dictionaries, but instead of using a signal as a key, we use a number. Constant combinators are placed mapping each signal to a unique number (such as 1 yellow belt, 2 red belt, 3 blue belt, 4 burner inserter, etc). Then, use a combinator of "each = index OUTPUT 1 of each" and plug that in as the input to a dictionary.{{clear}}
[[File:combinatorMultiplierMath.png|left|500px]]

((A+B)^2 - (A-B)^2)/4 = AB
(A+B)^2 - (A-B)^2 = 4AB
(A^2 + 2AB + B^2) - (A^2 - 2AB + B^2) = 4AB
4AB = 4AB

{{clear}}

== See Also ==
* [http://www.factorioforums.com/forum/viewtopic.php?f=18&t=14556 Combinators 101 (Tutorial)]
* [[Tutorial:Circuit network cookbook]]
* [[Circuit network]]
* [[Arithmetic combinator]]
* [[Constant combinator]]
* [[Decider combinator]]

Tutorial:Circuit network cookbook

2024-08-28T18:55:57Z

Ndh:

''This is a '''beginners''' tutorial. See also the [[Circuit network]] page for an overview over the circuit network and the [[Tutorial:Combinator tutorial]] for an advanced tutorial.''
{{Languages}}

== Foreword ==
This page provides examples of simple circuit network designs and some not so simple designs that others can use, combine and modify. They are designed to be as easy to understand as possible. To see the settings of combinators without opening them, the option "Show combinator settings in "Alt-mode"" in the Interface/Alt-mode settings has to be checked and "Alt-mode" has to be turned on.

== Lights ==
[[File:LightWiredToChest.png|border|left|430px]]

=== Lamp showing chest content condition ===

This is one of the simplest possible use of circuit-network. A [[lamp]] is light depending on the number of goods (in this example empty barrels) in a chest.

==== Setting up circuit connection ====
<div style="margin-left:440px;">
* The lamp is connected to the chest.
* The lamp is set to light if the chest contain less than 10 empty barrels.

==== To set the light condition ====
* Open the lamp (left click on it).
* Set the input to barrels.
* Set the operator to < (less than).
* Set the constant number:
** Left click on the constant number
** Move the slider until 10 is shown, or edit the value box directly.
** Press set.

Depending on the condition you set, the lamp may light if the chest is empty, or if it contains the required quantity of items.

The drawback with this scenario is that the lamp has a white light , and is therefore difficult to differentiate from an ordinary lamp at night.
</div>
{{clear}}

[[File:ConditionalLights.png|border|left|430px]]

=== Conditional Lights ===
<div style="margin-left:440px;">
* In this circuit we connect a series of [[lamp]]s to a [[storage tank]].
* By setting different conditions on each lamp we can build an indicator strip.
* The Enabled condition of the first lamp is '''Petroleum gas > 100'''.
* The others light up when gas is greater than 200, 300, 400 and 500 respectively.

In this setup you can connect the storage tank to the lamps directly.
</div>
{{clear}}

[[File:ColoredLights.png|border|left|430px]]

=== Colored Lights ===
<div style="margin-left:440px;">
To light a [[lamp]] with a color rather than white, you need an intermediate device like an [[arithmetic combinator]] that can send a color signal.
Instead of directly connect the [[lamp]] and the [[Storage tank]] you need:
# Add the arithmetic combinator.
# Connect the [[storage tank]] with the input of the arithmetic combinator.
# Connect the output of the [[arithmetic combinator]] with the lamp.
# Set up the arithmetic combinator:
## Setting the input to petroleum Gas + 0 (the constant 0 not the signal 0)
## Set the output to the pink signal (on the bottom row of the last tab of signals.)
# Set up the [[lamp]]:
## Select the "Use colors" check box on the lamp.
## Set the condition to the pink signal, and what value you want (i.e. > 100)
</div>
{{clear}}

== Oil Setups ==
Balancing the production of petroleum gas, light oil and heavy oil is one of the most important use cases of the circuit network.

[[File:LgtOilCracking.png|border|left|430px]]

=== Light Oil Cracking ===
<div style="margin-left:440px;">
* This circuit provides balanced light oil and petroleum gas production by cracking excess light oil into gas.
* The [[pump]] is connected to the [[storage tank]] by a [[red wire]].
* The pump has an enabled condition set to '''Light Oil > 20000'''.
</div>
{{clear}}

[[File:HvyOilCracking.png|border|left|430px]]

=== Heavy Oil Cracking ===
<div style="margin-left:440px;">
* This circuit extends on the previous circuit by adding optional heavy oil cracking to provide lubricant etc.
* The pump has an enabled condition set to '''Heavy oil > 20000'''.
</div>
{{clear}}

=== Alternative Setup for Cracking and Lubricant Production ===
This setup compares different fluid levels to each other instead of checking fixed values. It offers some guarantees such as petroleum gas being produced when you have light oil to spare, and light oil not being cracked when you have plenty of petroleum gas, and similar rules for heavy oil cracking and lubricant production.

[[File:oil-single-cct.png|border|left|430px]]

<div style="margin-left:440px;">
It takes 4 steps:

# Have a fluid tank for heavy oil, light oil, petroleum gas, and lubricant. For each fluid, make sure to connect the tank via pipes to every location where the fluid is being produced or consumed.
# For each chemical plant (or each row of them, if you use rows) add a pump to the non-water fluid input pipe to make it possible to block the flow. Note: Alternatively, the blocking pumps could be added to the chemical plant output pipes, but there is no need to add pumps to both inputs and outputs.
# Connect every pump and every fluid tank to a single circuit network of red (or green) wire. The resulting circuit network will know about the fluid level in every storage tank and pass this information to every pump.
# For each connected pump set the circuit “enable condition” to "[input fluid] > [output fluid]" , for its respective chemical plant recipe. E.g. set "heavy oil > light oil" for the heavy oil cracking input pump, set "heavy oil > lubricant" for the lubricant production input pump, and set "light oil > petroleum gas" for the light oil cracking input pump.

Done! Now all the pumps will move to equalize the fluid levels to each other. This will prevent fluid system deadlocks where you have plenty of one fluid but you are unable to make any of the other.
</div>
{{clear}}

== Misc ==
[[file:MulitipleChestsAndPoles.png|border|left|430px]]

=== Multiple Storages ===
<div style="margin-left:440px;">
* If you connect multiple chests to a pole, the pole displays the sum of items in all the chests.
* This also works with [[storage tank]]s and [[roboport]]s.
</div>
{{clear}}

[[File:ConstantComb.png|border|left|430px]]

=== Constant Combinator ===
<div style="margin-left:440px;">
* With a [[constant combinator]] you can generate any signals you may need.
* In this example we have generated a signal of 50 Laser turrets and 200 Piercing round magazine.
* Constant combinators are not of much use on their own but we shall use them later.
</div>
{{clear}}

[[File:ThisASign.png|border|left|430px]]

=== Constant Combinator Signs (Words) ===
<div style="margin-left:440px;">
* You can use [[constant combinator]]s to make signs, just set the letter signals in the combinator, each combinator can display 2 characters side by side.
* Note that to see these letters, Alt-mode must be on and the Interface setting “Show combinator settings in “Alt-Mode”” must also be enabled.
</div>
{{clear}}

[[File:constant_combinator_signs2.png|border|left|430px]]

=== Constant Combinator Signs (Managing Belts) ===
<div style="margin-left:440px;">
* Somewhat similar to the previous example, constant combinator signals can be used with belts to help indicate what items should be on which belts. This is extremely useful when sharing blueprints, as it's possible for blueprints to be shared albeit with no indication on which items are meant for which belts.
</div>
{{clear}}

[[File:MemoryCell.png|border|left|430px]]

=== Memory Cell / Counter ===
<div style="margin-left:440px;">
* Basic memory cell that counts all the items moved by the inserter
* The [[fast inserter]] is connected to '''BOTH''' ends of the arithmetic combinator.
* If the fast inserter hasn't picked anything up this tick the input to the Arithmetic combinator is the same as and output and hence the values are persisted.
* When the fast inserter does pick something up its value is added to the output from the previous tick thus incrementing that item.
</div>
{{clear}}

== Inserters ==
[[File:LimitItemsPlacedIntoAChest.png|border|left|430px]]

=== Limit items placed into a chest ===
<div style="margin-left:440px;">
* The [[inserter]] is connected to the [[wooden chest]] using a [[red wire]].
* The inserter's enabled condition is '''Advanced Circuit < 10'''.
* In reality this means the inserter may place more than 10 Advanced circuits in the chest because it could pick up to 3 at once due to stack size bonuses.
* This effect can be even greater with Stack inserters because of their large carrying capacity.
* This technique still gives far greater control than limiting the inventory on the chest.
</div>
{{clear}}

[[File:BalancedChestInsert.png|border|left|430px]]

=== Balanced chest insert ===
<div style="margin-left:440px;">
Goal: Load n chests with approximately the same number of items. This can be used for train stations: [https://www.reddit.com/r/factorio/comments/4e03g2/madzuris_smart_loading_train_station_guide/ MadZuri's smart loading train station]
* Place n chests and n inserters.
* Place 1 [[arithmetic combinator]]
* Set the combinator to take Each (yellow star) and divide by the negative number of chests. ie −n.
* Connect all chests to each other and to the input of the combinator using red wire.
* Connect all inserters to each other and to the output of the combinator using red wire.
* Connect each inserter to the box it inserts into with green wire.
* Set the enable condition on each inserter to be Everything (red star) < 0.

The combinator calculates the average number of items in the chests, and makes it negative. Each inserter gets the amount in the chest it is inserting to and adds the negative average, i.e. it calculates how many more than the average it has in its chest. Thus if that number is negative, it has less than the average in the chest and it enables.

Due to inserter stack bonus the count is not exact. If a precise count is needed, set the inserter stack size to 1.
</div>
{{clear}}

[[File:SmartOutpostUnloader.png|border|left|430px]]

=== Keeping outpost stocked with specified items ===
<div style="margin-left:440px;">
* This circuit keeps a [[storage chest]] at an outpost stocked with customized levels of different items.
* For example you could keep an outpost stocked with 50 laser turrets and 200 piercing magazine rounds but not have to worry about it being over filled.
* The [[storage chest]] is attached to the input of the [[arithmetic combinator]] (left side in the picture) with a [[red wire]].
* Another couple of [[red wire]]s join the output of the [[arithmetic combinator]] (right side) to the [[constant combinator]] and to the [[stack filter inserter]].
* The [[arithmetic combinator]] '''multiplies''' each input value (from the storage chest) by '''-1'''.
* Finally the filter stack inserter's mode of operation is set to '''Set filters'''.
* So the input to the [[stack filter inserter]] is '''<constant combinator> - <storage chest contents>''' and the filter is set to filter for the first item by inventory order.
</div>
{{clear}}

[[File:SolarAccumalatorBalancer.png|border|left|430px]]

=== Balanced Solar panel / Accumulator Production ===
<div style="margin-left:440px;">
* This circuit balances production of [[solar panel]]s and [[accumulator]]s to a desired ratio in my case 24:20.
* The first [[arithmetic combinator]] takes the number of accumulators in the chest and '''multiplies''' it by '''24'''.
* The second [[arithmetic combinator]] takes the output of the first combinator and '''divides''' it by '''20'''.
* This gives us the number of accumulators that we can directly compare to the number of Solar panels in both inserters.
* If the number of accumulators is greater we enable the Solar panels inserter, if the number of Solar panels is greater we enable the accumulators inserter.
* However, if they are equal, neither machine does anything. So we add a single accumulator to one of the inserters using a constant combinator and a wire of the other color, therefore breaking the deadlock.
</div>
{{clear}}

== Sushi Belts ==
[[File:SushiScience1.png|border|left|430px]]

=== Reading Belt Design ===
<div style="margin-left:440px;">
* Six belts in a row are connected with Red wire and set to '''Read belts contents''' and '''Hold'''
* This [[red wire]] is then connected to the inserters that insert onto the belt.
* Read hand contents is unselected for all inserters.
* Mode of operation is set to '''Enable/Disable''' on all inserters.
* The first inserter is enabled when '''Automation science pack = 0'''
* The other inserters are set similarly for the other science packs.
</div>
{{clear}}

[[File:SushiScience2.png|border|left|430px]]

=== Memory Cell Design ===
<div style="margin-left:440px;">
* This circuit counts the number of items of each type on a looping belt by counting the numbers that are added and removed from the belt by inserters.
* Each inserter that takes items off the belt is connected together with Red wire and each of these inserters is set to '''Mode of operation none, Read hand content selected''' and '''Hand read mode pulse'''.
* These inserters are connected to the input of the left arithmetic combinator.
* The left [[arithmetic combinator]] multiples '''each''' input by '''-1''' and outputs it to '''each'''.
* The right [[arithmetic combinator]] is a '''memory cell''' as above.
* The memory cell's input is connected to the inserters that are placing items on the belt and the output of the left [[arithmetic combinator]].
* The inserters that place items onto the belt have an enabled condition that is based on the number of items on the belt.
</div>
{{clear}}

== Power ==
[[File:SteamBackup.png|border|left|430px]]

=== Backup steam power ===
<div style="margin-left:440px;">
* The [[steam engine]]s are not directly connected to the power network. They are connected to the power network through a [[power switch]].
* The [[power switch]] is connected to one of the [[accumulator]]s in the main network.
* The [[power switch]] turns on when A < 10. That is when the [[accumulator]]s are less than 10% full.
</div>
{{clear}}

=== Optimal usage of fuel for nuclear power ===
Unlike the normal steam power that adjusts fuel usage based on power usage, the [[Power_production#Nuclear_power|nuclear reactors]] spend fuel in fixed units of time. To be exact, the consumption of 1 fuel cell takes exactly 200 seconds.

Combined with the fact that creating the nuclear fuel cells are time consuming and expensive to create, it is therefore beneficial to optimize their use to match the actual consumed power.

[[File:NuclearCircuits.png|border|left|430px]]
<div style="margin-left:440px;">
This picture shows a setup with 4 reactors, that spend only 1 fuel cell each whenever steam runs low.<br>
''Note: The GUI in the image above has been altered to make sure all important info fits within the image size.''

There are a few elements in this setup:
* Storage tank that provides the [[steam]] signal. You should only read from one storage tank, and it should have pipe connections to all your other steam storage tanks.
* Chests containing [[uranium fuel cell]]s for the reactor.
* Output inserter that takes [[Used_up_uranium_fuel_cell|empty fuel cells]] from the reactor. This is connected to the storage tank to listen for the steam signal, and to the chests to listen for the uranium fuel cell signal. If the steam level is low and there are uranium fuel cells available, it removes the empty fuel cells from the reactor and sends an empty fuel cell signal (since "Read hand contents" is checked).
* Input inserter that put uranium fuel cells into the reactor. This is connected to the output inserter and listens for the empty fuel cell signal. The "Override stack size" is set to 1, so that it only inserts 1 fuel cell at a time.
* If you are using multiple reactors you should only wire one output inserter to one steam tank, and then connect all input inserters to the single output inserter. This will synchronize fuel insertion to maximize the reactor neighbour heat bonus. The other reactors can have "dumb" output inserters that remove [[Used_up_uranium_fuel_cell|empty fuel cells]] immediately.

Since this design uses empty fuel cells as a signal to fill the reactor, you need to manually insert 1 uranium fuel cell into the reactor to get it started.
</div>
{{clear}}

=== Prioritize usage of uranium towards nuclear fuel production ===
Because a continuous supply of [[uranium fuel cell]]s is critical to maintaining a [[nuclear reactor]], the circuit network can be used to set up a system where [[uranium-235]] and [[uranium-238]] are conserved for the production of nuclear fuel before other uses.

[[File:Nuclear Fuel Circuit Network.png|border|left|430px]]
<div style="margin-left:440px;">

Using a [[splitter]], divert the two types of uranium onto two parallel conveyors, with an [[inserter]] positioned to gather uranium from each conveyor (a [[long-handed inserter]] will be needed for the far belt). Each of these inserters deposits their load into a container, from which two more inserters deliver the contents to an [[assembling machine]] making nuclear fuel. An inserter delivers the produced fuel to a third container, from which inserter(s) delivers the fuel to your nuclear reactor. Wire the two inserters gathering from the conveyors to the container each of them is delivering to, and to the tile of conveyor immediately after the tile the inserter is gathering from. Set each inserter's enable condition to "less than or equal to X amount of uranium", using the appropriate type of uranium the inserter is gathering and X being the number of reserve uranium desired (optimally, one uranium-235 and nineteen uranium-238, the amount needed to produce nuclear fuel; the amount may be increased if a greater stockpile is desired). Set each conveyor's enable condition to "greater than or equal to X amount of uranium" in the same manner. Finally, connect the inserters delivering uranium to the assembly machine up to the container the assembly machine is delivering nuclear fuel to, and set each of their enable conditions to "nuclear fuel = 0 (the enable condition can be set to "less than or equal to X amount of nuclear fuel" if a larger stockpile is desired).

This set-up accomplishes the following:

* When there is sufficient nuclear fuel and uranium stockpiled, the inserters will deactivate and the conveyors activate, allowing the uranium to continue down the conveyors to other facilities.
* When the nuclear fuel stockpile hits zero (or decreases below the desired amount), the inserters delivering to the assembly machine will activate and deliver uranium to resume production of nuclear fuel until quota is reached again.
* When there is not enough uranium stockpiled to produce a batch of nuclear fuel, the inserters gathering uranium will activate and and resume gathering uranium until they reach their quota. The conveyors carrying uranium will stop past the inserters, cutting off other facilities from that type of uranium until its respective inserter reaches quota.
* The assembly machine will only be provided with uranium when the stockpile of nuclear fuel hits zero (or decreases below the desired amount), preventing over-production of nuclear fuel and thus over-consumption of uranium.
</div>
{{clear}}

== Railway network ==
=== Set train routing ===
The circuit network can be used to allow deeper micromanagement of [[train]]s. Circuits can be used to adjust train limits for [[Train stop|stops]], effectively disabling a stop when a resource is not available for loading, or if an unloading station already has more than enough of a resource. Note that adjusting train limits runs into fewer problems than fully enabling/disabling stops; see [https://factorio.com/blog/post/fff-361 Friday Facts #361 - Train stop limit, Tips and tricks] and the [[Train stop]] page for additional information about using train limits.

=== Player safety ===
The circuit network can be used to ensure the player's safety when crossing train tracks so they do not get hit. Place [[gate]]s at designated crossing areas and connect an adjacent [[wall]] to [[rail signal]]s near the gate. Set the gate to "read sensor" and the signal to "close signal" with the condition being the signal the gate sends out being "1". This means that when the gate is closed, the signal will be green and trains can pass freely, but when the player approaches the gate and it opens for them, the train signal will be turned red and trains will be stopped until the player clears the area.

Alternatively, this system can be reversed - by setting the gate to "open gate" and the train signal set to "read signal", the gate will remain open normally and will close when a train is approaching, preventing the player from crossing until it is safe.

In lieu of gates, the player can connect a [[programmable speaker]] to the train signals to broadcast a warning siren when a train is approaching the area.

== Latches ==
=== RS latch - single decider version ===
[https://forums.factorio.com/viewtopic.php?f=193&t=14556 This discussion] on the Factorio forums starts with the common 2 decider RS latch version, but later a [https://forums.factorio.com/viewtopic.php?p=111192#p111192 single decider version was proposed]. The thread [https://forums.factorio.com/viewtopic.php?p=160896#p160896 goes on to explain] why this is better. In the thread, the latch is described as an SR latch. However, when both inputs are true, the latch will reset, so it is an RS latch.

==== Backup steam example ====
This example will turn on the steam generator when the Accumulator charge drops to 20%, but will "latch" (remember) the On state until the accumulator is charged to 90%.

Latching is used to introduce [[Wikipedia:hysteresis|hysteresis]] and avoid the power switch rapidly cycling on and off (as the accumulator falls to 19%, charges to 20%, falls to 19% and so on).
[[File:SR-01-Layout.png|850px|left]]
{{clear}}
{{BlueprintString|bp-string=0eNrFVk1vozAQ/SuVz1ABCaRBq5WqXntKjqsKOTBJR8IGGTtpFPHfd+w0HyU0G6pVewkxnnmemfdmzI4tSgO1QqlZumOYV7Jh6Z8da3AleWnf6W0NLGVrVNrQG49JLuyLvYU/Z63HUBbwxtKw9QZ4zs48o15P1CBObgXkWIDy80osUHJdqTOAUfviMZAaNcI+A7fYZtKIBSiK7YgjoEAjfCgh1wpzv65KoFPqqiHnStrzCdAPA49t6Rm1NrYOWjQY7QrY6FQZwcvyX1jJFajxEYrnuRGmdGW6DCe+jx1KcB9TDYl1raoyW8ArXyM5kFVldG10djObj6zdI0kKHp2Mdiy0PysFIM8pwYKldHyOKjeo3TI8y8Wup93tl7Yv3fiaOC6zjt6z9uk4VqDaR+rY7CvBO2ZGewUec1qiaobVxaE3mtseiwK7EjVXLsaU/SKPobWe7zHrLYVmpM6WqhIZSsJg6ZKXDQyiYkzF9Vhk9xUU3d3kNiaSQUwEB/l9Hw+uZg1YjGzYiPpA1+/vpKuHjk7fRNf7JrJTsZf05MLwoIFbzLvtOvlEFZNjKepqQ5poNqjz10s9jA6N+fk8Ohx/FMFXNXDqxeCC20F901vCJxN07UjVG9K4+x9YQp5M2LUZfbTpq+XDKRsNnG4cuULZcz089HZWD+D0a8Pz52bnNPgPzTj76dlJAnDfNenZp5fHSr4ACp/NZ3fPnHrkDt64qN31vwbVuFIn43GUjCdxHIVt+xcL2lBp}}
{{clear}}
[[File:SR-02-Accumulator.png|left]]Accumulator outputs the current charge level as % on signal [[File:Signal-A.png|21px]]
{{clear}}
[[File:SR-03-RangeDeciders.png|left]]First decider outputs "Set" ([[File:Signal-S.png|21px]] = 1) if Accumulator is less than 20%.
Second decider outputs "Reset" ([[File:Signal-R.png|21px]] = 1) once Accumulator is more than 90% full.
{{clear}}
[[File:SR-04-SRLatch.png|left]]

==== RS Latch configuration ====
'''The central decider and green feedback wire is the actual RS Latch.'''
It latches the Set signal [[File:Signal-S.png|21px]] until the Reset signal [[File:Signal-R.png|21px]] is received (and vice-versa).<br />
NB: the latch expects binary inputs ([[File:Signal-S.png|21px]] & [[File:Signal-R.png|21px]] must be 0 or 1) - this is why the previous two deciders are required.<br />
When both inputs are true, the reset signal takes priority and the latch resets. This means it is an RS latch instead of an SR latch.
<br clear=all>
[[File:SR-05-PowerSwitch.png|left]]The Power switch isolates the generator from the rest of the factory until [[File:Signal-S.png|21px]] = 1
<br clear=all>
----

[[File:SRLatch.png|border|left|430px]]

=== RS latch ===
<div style="margin-left:440px;">
* This should be familiar to anyone with any background in electronics.
* The signal is set and reset with the [[constant combinator]]s on the left by setting an A=1 signal.
* The latch "remembers" which one was last set and the light stays on until another signal is received.
</div>
{{clear}}

[[File:SRlatchinaction.png|border|left|430px]]

=== Usage of RS latch ===
<div style="margin-left:440px;">
* Here is an example of how you could use an RS latch.
* The two extra [[decider combinator]]s provide the set and reset conditions.
* Petroleum gas < 50 and petroleum gas > 100.
</div>
{{clear}}

[[File:BeltLatch.png|border|left|430px]]

=== Belt only latch ===
<div style="margin-left:440px;">
* To make it work, '''3''' pieces of raw wood must be placed on the inside lane of the belt.
* It will have higher latency than the combinator version, but in most situations you will not notice the difference.
</div>
{{clear}}

== Displays ==
[[File:5digitDisplay.png|border|left|430px]]

=== Numerical Display ===
<div style="margin-left:440px;">
* Each digit is driven by its own [[green wire]], that wire holds 15 signals, one for each lamp used in the digit.
* [[constant combinator]]s are used to define which lamp should light up for each value.
</div>
{{clear}}

[[File:BWDisplay.png|border|left|430px]]

=== Black and White Grid Display ===
<div style="margin-left:440px;">
* Each row has its own [[red wire]] connection and within that row each light has a numbered signal 0-9.
* We turn each light on by just setting or clearing the relevant signal.
</div>
{{clear}}

[[File:MultiColoredDisplay.png|border|left|430px]]

=== Multicolor Display by DaveMcW ===
<div style="margin-left:440px;">
* To understand how this works, you first need to understand how color lights choose which color to light up when there are multiple colored signals.
* The [[lamp]] will light up with the colored signal that is greater than zero and earliest in this list: red, green, blue, yellow, pink, cyan, white.
* We have a [[red wire]] per column, that wire has each of the colored signals on it at different values and a numbered signal for each row.
* There is a [[arithmetic combinator]] for each cell that subtracts the "row" value from each of the colored signals.
* And this enables us to choose the color for each cell.
* Simple!
</div>
{{clear}}

== See Also ==
* [[Arithmetic combinator]]
* [[Constant combinator]]
* [[Decider combinator]]
* [[Circuit network]]

2024-06-27T17:41:20Z

Ndh: Created page with "<div class="toccolours mw-collapsible mw-collapsed"> Blueprint <div class="mw-collapsible-content">0eNqlU11rwzAM/C96TkuStWvqh8F+xyghH2orSOygyGWh5L/PjkcJJetW9hKQLd2d7pwrlI3FjkkLqCtQZXQP6uMKPZ100fgzGToEBSTYQgS6aH1VY0U18qoybUm6EMMwRkC6xk9QyRj9CuCJpNCyjJCOhwhQCwlh0DMVQ65tWyI7iodAEXSmd7NGe36Ht9sk620EA6jVNsvWW8fk5oRNk5d4Li7khlznkRpB/sGAC7FYd3JjDh2rd5jQrHcwiWcmHAKLxsor6T1U4j8nRtTzpah2G7te4sqSTKWfHr2Nd3unjxJYWPtu6Zo4qAmECxZ8w+burqab7iNxL/mfLcEL8iBn0qfgTUgIVOyLtit4kqvgzU0aK539B3Y..."

<div class="toccolours mw-collapsible mw-collapsed">
Blueprint
<div class="mw-collapsible-content">0eNqlU11rwzAM/C96TkuStWvqh8F+xyghH2orSOygyGWh5L/PjkcJJetW9hKQLd2d7pwrlI3FjkkLqCtQZXQP6uMKPZ100fgzGToEBSTYQgS6aH1VY0U18qoybUm6EMMwRkC6xk9QyRj9CuCJpNCyjJCOhwhQCwlh0DMVQ65tWyI7iodAEXSmd7NGe36Ht9sk620EA6jVNsvWW8fk5oRNk5d4Li7khlznkRpB/sGAC7FYd3JjDh2rd5jQrHcwiWcmHAKLxsor6T1U4j8nRtTzpah2G7te4sqSTKWfHr2Nd3unjxJYWPtu6Zo4qAmECxZ8w+burqab7iNxL/mfLcEL8iBn0qfgTUgIVOyLtit4kqvgzU0aK539B3Y35JP5+ZFNm5N2YKCELY7P2J/MvF6II53CTJ9Lzz3h6c2r2T8WgZPfhwCyZLPbp7vsdR+/xJtx/AJNbzZ8</div>
</div>

== Memory ==
How to store a constant value for later use, either for a basic counter or for more advanced logic. A decider combinator wired output tied to input and configured greater than zero (for positive values), input -> output will 'hold' a value, as long as all other inputs on the network are zero.

Any non-zero input condition will create a basic clock; incrementing the stored value by the sum of all connected input values every cycle. A single pulse of an input will cause a single increment by the pulsed value. Reset to zero occurs whenever the set condition is no longer met, or if a negative pulse equal to the input occurs.

== Basic clocks ==
[[File:Timer.png|thumb|right|377px|A basic clock. 30 ticks is the ceiling for Signal 1; which is continuously added.]]
Clocks are constructed by having the output of a combinator tied back to its own input, such that every cycle advances its own count. Either the arithmetic combinator or the decider combinator can be used.

An arithmetic combinator tied to itself is fun to watch and will happily run-away, but requires additional control logic to reset.

A self-resetting clock requires just a single decider combinator with output wired to input and configured with Less Than (<) and Input -> Output. When a constant combinator is then connected to the input, every cycle it will count up by the value of the Constant Combinator until the set conditional value is reached, then output a zero which will be summed with the constant combinator, and reset the process.

The clock sequence will not include zero, will begin at the value set by the constant combinator, and will include whatever value eventually causes the conditional to be false. An arithmetic combinator can modify the clock sequence but remember its outputs will occur one cycle later than the clock cycle values.

A clock that only counts once can be built using the following setup:

[[File:Onetime_Clock.png|thumb|none|360px|One-time clock. Runs until T=Z+1. Reset via R>0.]]

== Pulse generators ==

Connecting an additional (=) decider combinator to the output of a basic clock will create a pulse generator, and will pulse a single output every time the clock cycles through the set condition. Any output value can be used, either directly from the clock sequence (input->output), a 1, or some value on a separate logic channel on the circuit network, such as set by a constant combinator. or by the circuit network.<br />
[[File:PulseGen.png|500px]]
*''The value 1 can be written as any positive integer, so long as it is within the cap or ceiling of your timer.''
*''As an example from the above timer, this light will pulse every 1st tick after the timer reaches 30 ticks, making it pulse 1/30th of a second, as Factorio updates at 60 times per second.''

== Counter ==
A counter is used to count the number of input events, and output the sum of that count. Any pulsing input into a decider combinator configured input -> output and wired between output and input will create a counter, but this input must be zero at all other times or else the combinator will run away like a clock. A pulse generator is normally used to accomplish this. Combining several gating decider isolators set with sequential conditionals, a clock, and a pulse generator to the input of a counter will allow remote polling and counting of each isolator's contents.

== Memory cells ==

=== Simple latch ===

When looping the combinator to itself, use a different color of wire from your main inputs or outputs.

[[File:SimpleLatchv2.png|415px]]

Truth Table:

{| class="wikitable"
|-
!Output 1!!Input 1!!Input 2!! Output 1 (t+1)
|-
| 0 || 0 || 0 || 0
|-
| 0 || 1 || 0 || 1
|-
| 0 || 0 || 1 || 0
|-
| 0 || 1 || 1 || 0
|-
| 1 || 0 || 0 || 1
|-
| 1 || 1 || 0 || 1 ''(2)''
|-
| 1 || 0 || 1 || 0
|-
| 1 || 1 || 1 || 1 ''(2)''
|-
|}
''Output 1 is the green wire loop seen in the picture, it carries the value to latch.''

''Input 1 is Set, while Input 2 is Reset.''

=== Positive cell ===

Cell for storing a positive value, with reset support:

[[File:AdvancedMemoryCell.png|500px]]

Connect the desired value as signal I on the right side to set the memory cell and connect a negative value as signal I to reset the cell.

* The output of the memory cell is 2 mutually exclusive signals.
** In case input signal I > 0 then signal I is passed to the other side.
** In case input signal I is interrupted, then signal M is passed instead as a memory of previous input value.
* When input signal I is interrupted, it takes 2 ticks to switch to memory signal M.
* In case input I signal lasts only one tick then memory cell starts to cycle between the 2 previous values, tick by tick. Indefinitely.
* Switching is seamless, e.g. there are no ticks with empty signal.

=== Positives and negatives cell ===

This cell can store negatives or positives. Reset is done on a dedicated line. Additionally, a 1-tick burst is handled properly. [https://forums.factorio.com/viewtopic.php?f=193&t=60330&p=362377#p362377 Forum post].

* The output M (memory) is the last non-zero input I (Input).
* A non zero R (reset) signal sets the output to zero.
* 1-tick bursts of R or I are handled properly.
* Negatives are handled properly.

[[File:Memory_cell_with_negatives.png|500px]]

== Multiplier and Dictionaries/Arrays ==
[[File:combinatorMultiplierDetailed.png|left|500px]]
* Multiplying two signals together is simple and requires only a single combinator, however multiplying a set of signals is more complicated.
* A proof is shown below for the equation and why it works.
* A dictionary is a system that allows a value on a specific signal to be accessed. For example, A can contain many signals (either from a constant combinator or memory cell) and B can contain 1 of a specific signal (such as blue signal). What remains is the blue-signal value from A. This is because all the other signals are multiplied by 0.
* Arrays are similar to dictionaries, but instead of using a signal as a key, we use a number. Constant combinators are placed mapping each signal to a unique number (such as 1 yellow belt, 2 red belt, 3 blue belt, 4 burner inserter, etc). Then, use a combinator of "each = index OUTPUT 1 of each" and plug that in as the input to a dictionary.{{clear}}
[[File:combinatorMultiplierMath.png|left|500px]]

((A+B)^2 - (A-B)^2)/4 = AB
(A+B)^2 - (A-B)^2 = 4AB
(A^2 + 2AB + B^2) - (A^2 - 2AB + B^2) = 4AB
4AB = 4AB

Factorio talk:Style guide

2024-06-27T17:30:12Z

Ndh: Created page with "== How can I add a blueprint? == I would like to edit https://wiki.factorio.com/Tutorial:Combinator_tutorial#Memory, and I would like to add blueprints to make it easier to follow along. I would very much appreciate some guidance on the preferred way of sharing blueprints here on the Wiki. --~~~~"