The Big Furnace Krastorio Compatible

LuaComb++

Overview

LuaComb++ executes restricted Lua scripts inside a circuit combinator. A script can read the green and red input wires, combine their signals, retain controlled data between executions, and produce independent persistent outputs.

The project began as a fork of Moon Logic 2 by Chilla55 and has since been extensively reworked around a guided editing workflow, Factorio 2.0 signal qualities, deterministic execution, and multiplayer safety.

---

Main features

Circuit interface

• Read the green wire with g, the red wire with r, or their combined total with get.
• Address signals by name, type, and quality.
• Aggregate all qualities or select one exact numeric quality level.
• Write independently to the green or red output wire.
• Keep outputs active until they are changed, removed with count 0, or cleared explicitly.

State and scheduling

• Store private per-combinator data in self.
• Share data-only global variables between LuaComb++ combinators belonging to the same force.
• Choose an execution interval from the editor: every tick, every 6 ticks, or once per second.
• Preserve the last valid outputs if execution fails.

Guided editor

• Live input and output signal panels.
• Contextual suggestions for Lua, signals, properties, and LuaComb++ functions.
• Factorio signal picker for exact signal descriptors.
• Script formatting and translated Help.
• Recovery of the last successfully compiled script.
• Personal library for up to ten named scripts.
• Settings copy and blueprint support.

Runtime protection

• Restricted, deterministic Lua environment.
• Limits for instructions, source size, strings, tables, nesting, persistent data, and signals.
• Isolated failure handling for each combinator.
• Force-scoped alerts for connected players when a script is disabled.

---

Design lineage and focus

Moon Logic 2 and LuaComb++ share the same central idea: express circuit-network logic with Lua. Their interfaces emphasize different styles of use.

| Area | Moon Logic 2 approach | LuaComb++ approach | |---|---|---| | Editing workflow | Compact code window designed for short scripts and pasted logic | Guided editor with live panels, completion, formatting, Help, and recovery tools | | Circuit access | red, green, and out tables | Quality-aware g, r, and get records with explicit output functions | | Signal identity | Direct name-based wire access | Explicit type + name + quality identity with convenient aggregate access | | Persistent state | Per-combinator var data | Per-combinator self data plus force-wide shared globals | | Scheduling | Script-controlled delay and irq values | Per-combinator execution profile selected from the editor | | Output style | Assignment through the persistent out table | Persistent set, g.set, r.set, and clear operations | | Runtime goal | Lightweight programmable circuit transformations | Bounded execution, deterministic shared state, and controlled multiplayer behavior | |Mods data|Great feuture wich provide data from prototypes and other mods stuff|Not implemented|

LuaComb++ keeps the programmable-combinator concept while offering a workflow aimed at players who want to build and debug scripts directly inside the game.

---

Quick start

1. Place a LuaComb++ combinator.
2. Connect its input and output circuit wires.
3. Open the editor and choose an execution interval.
4. Write the script.
5. Press Compile, validate and save.

Editor changes remain drafts until validation succeeds.

local plates = get["iron-plate"].count

if plates < 100 then
    g.set("signal-A", 1)
else
    r.set("signal-A", 1)
end

---

Script reference

Available functions

LuaComb++

| Function | Description | |---|---| | clear() | Removes every persistent output. | | set(signal, count [, quality [, type]]) | Writes a signal to both output wires. | | g.set(signal, count [, quality [, type]]) | Writes a signal to the green output. | | r.set(signal, count [, quality [, type]]) | Writes a signal to the red output. | | random(min, max) | Returns a random integer between the inclusive limits. | | print(...) | Adds values to the editor State panel. | | concat(table [, separator [, first [, last]]]) | Joins values into a size-limited string. |

random uses a private deterministic sequence for each combinator. Its state is saved with the map, and script validation does not advance the active sequence.

Basic Lua

| Function | Description | |---|---| | pairs(table) | Iterates over table keys and values. | | ipairs(table) | Iterates over consecutive numeric indices. | | next(table [, index]) | Returns the next table entry. | | select(index, ...) | Selects values from variable arguments. | | tonumber(value [, base]) | Converts a value to a number. | | tostring(value) | Converts a value to text. | | type(value) | Returns the Lua value type. | | assert(condition [, message]) | Raises an error when a condition is false. | | error(message [, level]) | Stops the script with an error. |

Mathematics

The shortcuts below are also available through math where applicable.

| Function | Description | |---|---| | abs(x) | Absolute value. | | ceil(x) | Rounds upward. | | cos(x) | Cosine in radians. | | exp(x) | Exponential value. | | floor(x) | Rounds downward. | | log(x) | Natural logarithm. | | max(...) | Largest argument. | | min(...) | Smallest argument. | | sin(x) | Sine in radians. |