Factorio Forums

ratchetfreak wrote:for definition per combinator you can use the circuit ID debug overlay and enumerate each combinator:

Code: Select all

Arithmetic, input green 4 input red 5, each * signal 0, output green 7 output red 10 signal each

Gus_Smedstad wrote:While I understand what you're trying to do, and I gatherer there's established precedent, I found that almost unreadable. My own experience is with procedural languages, so I don't know what the common choices are for describing circuits via text, but a quick search of Wikipedia suggests that something like Verilog would be a lot easier to read.

Keep in mind that you need to address the symbols somehow. Combinators don't just have "pins," they have symbols associated with those pins. A >= Combinator with "Green Science Pack 0 or 1" as an output is different from one with "Copper Plate 0 or 1" as an output.

Honestly, Verilog looks pretty primitive to me as well, like the first version version of C where function inputs inexplicably had their types declared after the function declaration instead of inline, as has been standard now for 30+ years.

Given my own devices I'd probably pattern a language after C or Pascal, with the symbols standing in for types (which are all integers). The main danger is that Combinators aren't really procedural, they're circuits.

Adil wrote:Unlike Gus_Smedstad I don't understand what are you trying to do.

y.petremann wrote: The idea is to have a language that would permit to describe circuit network,

y.petremann wrote:so instead of placing manually things and thinking of each things as a part of a whole big things, you would define small parts to use them in bigger parts and again, so it would be easier to define things like processors, memory and things like in the "Factorio leds banner".

Adil wrote:

y.petremann wrote: The idea is to have a language that would permit to describe circuit network,

Like for description of player creations? Aren't languages already in existence sufficient?

y.petremann wrote:so instead of placing manually things and thinking of each things as a part of a whole big things, you would define small parts to use them in bigger parts and again, so it would be easier to define things like processors, memory and things like in the "Factorio leds banner".

As in blueprints, right?

Adil wrote: Like for description of player creations? Aren't languages already in existence sufficient?

define Latch : connections( start : A, stop : B, result : A)
// this simple block takes two input signals, of types A and B. It outputs A as 1 until it receives B as 1.
{
  decider combinator_1( greater_than( A, B ), A as 1 ); // how you set the decider's dialog. Output is always "as 1" or "input count."
  
  connection( start , combinator_1 input )
  connection ( stop , combinator_1 input )
  connection( combinator_1 input, combinator_1 output ) // wire looping output to input, so A stays set.
  connection( result, combinator_1 output )
}

// example usage:
  circuit latch_1 Latch( combinator_2 output, combinator_3 output, combinator_4 input );

Gus_Smedstad wrote:You can't delete combinator connections, the only way to undo a wiring error is to delete an item and re-place it, and you lose the logic wires every time you do that.

y.petremann wrote: More of a language to describe thing to be exported to blueprint.

y.petremann wrote:Imagine you found the combinator configuration for an NAND gate, and then one for an RS latch made out of NAND gates, then ... then a whole processor made of all complicated stuff you have, you basically have a "blurprint" for that processor, but now imagine you found that a specific part repeated all hover you circuit is taking too much time or using too much combinators, you coul freely redesing this part and your complere processor would benefit from it.

Adil wrote: I wonder, how many people would actually go and do something like that.

Gus_Smedstad wrote:and the wiring is much, much harder to see than transport belts and inserters.

Gus_Smedstad wrote:

Adil wrote:I agree that I don't see much point in a language that can be compiled to create blueprint code. If you're going to do that, just paste the blueprint code.

• logarithmic display : really easy to setup, only use lamps configured at these values : 1,2,3,6,10,20,30,60,100,200,300,600,1000,2000,3000,6000 ...
• linear decimal display : quite more dificult to make but easier to read, you need to have a repeatable circuit that would divide by 10 for the next decimal each time and calculate the modulo so a line would represent a decimal number by it's number of lights on.
• 7-segment display : the hardest one but the most easy to read, you basicaly need the linear decimal display circuit and 7-segment displays.

ratchetfreak wrote:the netlist would allow discussing and compiling into sections. So when building the circuit you can use the sub assemblies to create a larger whole.

For a modulo operation requires a divide multiply and subtract. The netlist would allow describing that into a single component and let you repeat that throughout the larger build.

When buiding it you would put that into a blueprint and then stamp it down where you need it and only adjust the input and output combinators as needed.

ratchetfreak wrote:on reddit u/KHaim submitted this very nice diagram of his memory array design:



This is a very clean way of representing designs IMO

• A netlist language would still be interesting.
• This type of diagrams are really good to explaining the logic of a system, but not on building blueprints.
• Diagrams like that do not solve completely dependency.

cat "blueprint-file" | base64 -d | gzip -d > "uncompressed-blueprint-file"