Mindcode: a Mindustry Logic high-level language

Mindcode is a high-level language that compiles down to Mindustry Logic - mlog. Mindcode includes higher-level constructs, such as expressions, user-defined functions and control statements. Here are some examples to give you an idea how to use Mindcode:

Mindcode Source Code: Mindustry Logic:

#set syntax = strict;

// Import system libraries for advanced units and blocks functions
require units;
require blocks;

// These parameters can be changed in the compiled code
/// Configurable options:
param memory = cell1;
param unit = @poly;

// Coordinates of the map area to process
// By default an entire map is converted
param sw_x = 0;
param sw_y = 0;
param ne_x = @mapw;
param ne_y = @maph;

// Setting to true restores copper conveyors (useful for testing)
param downgrade = false;

// Upgrading in stripes of given width -- faster processing
// (Could be even wider, the build radius is ~20 blocks or so)
param width = 10;

// How close unit needs to get to the block being upgraded
param radius = 10;

/// Don't modify anything below this line.

// Declaring variables representing blocks linked to the processor
linked message1;    // Used to output messages to unless something else is found
linked switch1;     // Used to pause processing

// Title printed to messages to help identify the processor purpose
const title = "Conveyor upgrading\n";

// Setting up external variables
allocate heap in memory[0 ... 16];

// External cached variables:
// Initial value is read from the external memory into global variables.
// When reading, the cached value is used (no external memory access)
// When writing, the value written is propagated to the external memory too.
// The progress of the upgrade is automatically kept in the external memory.
external cached x, y, dx, dy;
external cached total;

// Global variables
var oldType = downgrade ? @titanium-conveyor : @conveyor;
var newType = downgrade ? @conveyor : @titanium-conveyor;

// This is a main code block
begin
    // Try to locate block to output messages to.
    // It is used by the units system library to output messages as well
    var messages;
    findLinkedBlocks(
        "Automatic conveyor upgrading\nTrying to locate message block", message1,
        @message, "Message", out messages, false);

// Ensure the values read from external memory are meaningful
    x = limit(x, sw_x, ne_x);
    y = limit(y, sw_y, ne_y);
    dx = dx == 1 ? 1 : -1;
    dy = dy > 0 ? width : -width;

// It is possible to pause/stop the processing by attaching a switch and activating it
    // When the switch is active, the program reinitializes and without attached memory,
    // the progress is lost.
    while !switch1.@enabled do
        // If we don't have an active unit, summon a new one
        if @unit.@dead != 0 or @unit.@controller != @this then
            waitForFreeUnit(messages, title, unit, rand(1000));
        end;

// Position the unit to the middle of the band inside the building area
        var ypos = limit(y + width \ 2, sw_y, ne_y);
        while not within(x, ypos, radius) do
            move(x, ypos);
        end;

// Upgrade all blocks in the band
        for var yrep in y .. min(ne_y, y + width - 1) do
            replace(x, yrep);
        end;

print(title);
        println($"Position: $x, $ypos");
        println($"Upgrades: $total");
        printflush(messages);

// Move to next position
        x += dx;
        if x > ne_x or x < sw_x then
            // Reached end, reverse the direction and move to the next strip
            dx = -dx;
            y += dy;
            x = limit(x, sw_x, ne_x);

if y > ne_y or y < sw_y then
                dy = -dy;
                y = limit(y, sw_y, ne_y);
            end;
        end;
    end;
end;

// Returns value of n limited to range min .. max
def limit(n, min, max)
    min(max(n, min), max);
end;

// If a block of type oldType is found at position,
// replaces it with newType
void replace(x, y)
    var type;
    var building = getBlock(x, y, out type);

if type == oldType then
        build(x, y, newType, building.@rotation, 0);
        // If the processor is too fast, we need to wait
        // for the unit to finish building the block
        do
            getBlock(x, y, out type);
        while type != newType;
        total++;
    end;
end;

129 lines of code

jump 2 always 0 0
print "Configurable options:"
set memory cell1
set unit @poly
set sw_x 0
set sw_y 0
set ne_x @mapw
set ne_y @maph
set downgrade false
set width 10
set radius 10
jump 13 always 0 0
print "Don't modify anything below this line."
read .x memory 0
read .y memory 1
read .dx memory 2
read .dy memory 3
read .total memory 4
set *tmp0 @conveyor
jump 21 equal downgrade false
set *tmp0 @titanium-conveyor
set *tmp1 @titanium-conveyor
jump 24 equal downgrade false
set *tmp1 @conveyor
set :findLinkedBlocks:message message1
set :messages null
print "Automatic conveyor upgrading\nTrying to locate message block"
set :findLinkedBlocks:n @links
jump 40 lessThanEq :findLinkedBlocks:n 0
op sub :findLinkedBlocks:n :findLinkedBlocks:n 1
getlink :findLinkedBlocks:block :findLinkedBlocks:n
print "\nFound: "
print :findLinkedBlocks:block
sensor :findLinkedBlocks:type :findLinkedBlocks:block @type
set :findLinkedBlocks:variable :messages
jump 38 notEqual @message :findLinkedBlocks:type
set :findLinkedBlocks:variable :findLinkedBlocks:block
set :findLinkedBlocks:message :findLinkedBlocks:block
set :messages :findLinkedBlocks:variable
jump 29 greaterThan :findLinkedBlocks:n 0
print "\nMessage: "
print :messages
printflush :findLinkedBlocks:message
op max *tmp65 .x sw_x
op min :limit*retval *tmp65 ne_x
set .x :limit*retval
write :limit*retval memory 0
op max *tmp65 .y sw_y
op min :limit*retval *tmp65 ne_y
set .y :limit*retval
write :limit*retval memory 1
set *tmp17 -1
jump 54 notEqual .dx 1
set *tmp17 1
set .dx *tmp17
write *tmp17 memory 2
op sub *tmp19 0 width
jump 59 lessThanEq .dy 0
set *tmp19 width
set .dy *tmp19
write *tmp19 memory 3
sensor *tmp21 switch1 @enabled
jump 0 notEqual *tmp21 false
op idiv *tmp35 width 2
sensor *tmp23 @unit @dead
jump 68 notEqual *tmp23 0
sensor *tmp25 @unit @controller
jump 84 equal *tmp25 @this
op rand *tmp28 1000 0
ubind unit
jump 76 notEqual @unit null
print "Conveyor upgrading\nNo unit of type "
print unit
print " found."
printflush :messages
jump 69 always 0 0
sensor *tmp32 @unit @controlled
jump 83 equal *tmp32 0
print "Conveyor upgrading\nLooking for a free "
print unit
print "..."
printflush :messages
jump 69 always 0 0
ucontrol flag *tmp28 0 0 0 0
op add :limit:n .y *tmp35
op max *tmp65 :limit:n sw_y
op min :limit*retval *tmp65 ne_y
ucontrol within .x :limit*retval radius *tmp38 0
jump 92 notEqual *tmp38 false
ucontrol move .x :limit*retval 0 0 0
ucontrol within .x :limit*retval radius *tmp38 0
jump 89 equal *tmp38 false
op add *tmp40 .y width
op sub *tmp41 *tmp40 1
op min *tmp43 ne_y *tmp41
set :yrep .y
jump 107 greaterThan .y *tmp43
ucontrol getBlock .x :yrep :replace:type :replace:building 0
jump 105 notEqual :replace:type *tmp0
sensor *tmp48 :replace:building @rotation
ucontrol build .x :yrep *tmp1 *tmp48 0
ucontrol getBlock .x :yrep :replace:type 0 0
jump 101 notEqual :replace:type *tmp1
op add .total .total 1
write .total memory 4
op add :yrep :yrep 1
jump 97 lessThanEq :yrep *tmp43
print "Conveyor upgrading\nPosition: "
print .x
print ", "
print :limit*retval
print "\nUpgrades: "
print .total
print "\n"
printflush :messages
op add .x .x .dx
write .x memory 0
jump 119 greaterThan .x ne_x
jump 135 greaterThanEq .x sw_x
op sub .dx 0 .dx
write .dx memory 2
op add .y .y .dy
write .y memory 1
op max *tmp65 .x sw_x
op min :limit*retval *tmp65 ne_x
set .x :limit*retval
write :limit*retval memory 0
jump 129 greaterThan .y ne_y
jump 135 greaterThanEq .y sw_y
op sub .dy 0 .dy
write .dy memory 3
op max *tmp65 .y sw_y
op min :limit*retval *tmp65 ne_y
set .y :limit*retval
write :limit*retval memory 1
sensor *tmp21 switch1 @enabled
jump 64 equal *tmp21 false

137 lines of code

Bug reports, suggestions and questions are welcome at the project page.

Program output (0 steps):

Compiler messages:

270 instructions before optimizations.
16 instructions eliminated by Temp Variables Elimination (2 passes, 6 iterations).
21 instructions eliminated by Dead Code Elimination (6 iterations).
3 instructions eliminated by Jump Normalization (2 passes, 6 iterations).
18 instructions eliminated by Condition Optimization (7 iterations).
14 instructions eliminated by Single Step Elimination (4 passes, 10 iterations).
1 instructions eliminated by Expression Optimization (3 iterations).
4 instructions modified by If Expression Optimization (3 iterations).
38 instructions eliminated by Data Flow Optimization (5 passes, 21 iterations).
1 loops improved by Loop Hoisting.
2 instructions added by Loop Rotation (3 iterations).
4 loop conditions were partially rotated.
6 instructions eliminated by Loop Unrolling (11 iterations).
3 loops unrolled by Loop Unrolling.
4 instructions eliminated by Function Inlining (11 iterations).
5 function calls inlined by Function Inlining.
3 instructions eliminated by Jump Straightening (7 iterations).
3 instructions updated by Jump Threading.
1 instructions eliminated by Unreachable Code Elimination (3 iterations).
10 instructions eliminated by Print Merging.
137 instructions after optimizations.
Code size and number of instantiations by function: Size Times AvgSize Function 86 1x 86.0 <no function> 18 1x 18.0 inline void findLinkedBlocks(in title, in message, in linkMap...) 15 1x 15.0 def waitForFreeUnit(in message, in preface, in unit_type, in initial_flag) 10 5x 2.0 def limit(in n, in min, in max) 8 1x 8.0 void replace(in x, in y)
Size: 137 instructions, performance: parsed in 161 ms, compiled in 32 ms, optimized in 354 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler