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 *tmp68 .x sw_x
op min :limit*retval *tmp68 ne_x
set .x :limit*retval
write :limit*retval memory 0
op max *tmp68 .y sw_y
op min :limit*retval *tmp68 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
op idiv *tmp36 width 2
sensor *tmp21 switch1 @enabled
jump 0 notEqual *tmp21 false
sensor *tmp23 @unit @dead
op notEqual *tmp24 *tmp23 0
sensor *tmp25 @unit @controller
op notEqual *tmp26 *tmp25 @this
op or *tmp27 *tmp24 *tmp26
jump 86 equal *tmp27 false
op rand *tmp29 1000 0
ubind unit
jump 78 notEqual @unit null
print "Conveyor upgrading\nNo unit of type "
print unit
print " found."
printflush :messages
jump 71 always 0 0
sensor *tmp33 @unit @controlled
jump 85 equal *tmp33 0
print "Conveyor upgrading\nLooking for a free "
print unit
print "..."
printflush :messages
jump 71 always 0 0
ucontrol flag *tmp29 0 0 0 0
op add :limit:n .y *tmp36
op max *tmp68 :limit:n sw_y
op min :limit*retval *tmp68 ne_y
ucontrol within .x :limit*retval radius *tmp39 0
jump 94 notEqual *tmp39 false
ucontrol move .x :limit*retval 0 0 0
ucontrol within .x :limit*retval radius *tmp39 0
jump 91 equal *tmp39 false
op add *tmp41 .y width
op sub *tmp42 *tmp41 1
op min *tmp44 ne_y *tmp42
set :yrep .y
jump 109 greaterThan .y *tmp44
ucontrol getBlock .x :yrep :replace:type :replace:building 0
jump 107 notEqual :replace:type *tmp0
sensor *tmp49 :replace:building @rotation
ucontrol build .x :yrep *tmp1 *tmp49 0
ucontrol getBlock .x :yrep :replace:type 0 0
jump 103 notEqual :replace:type *tmp1
op add .total .total 1
write .total memory 4
op add :yrep :yrep 1
jump 99 lessThanEq :yrep *tmp44
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
op greaterThan *tmp55 .x ne_x
op lessThan *tmp56 .x sw_x
op or *tmp57 *tmp55 *tmp56
jump 141 equal *tmp57 false
op sub .dx 0 .dx
write .dx memory 2
op add .y .y .dy
write .y memory 1
op max *tmp68 .x sw_x
op min :limit*retval *tmp68 ne_x
set .x :limit*retval
write :limit*retval memory 0
op greaterThan *tmp62 .y ne_y
op lessThan *tmp63 .y sw_y
op or *tmp64 *tmp62 *tmp63
jump 141 equal *tmp64 false
op sub .dy 0 .dy
write .dy memory 3
op max *tmp68 .y sw_y
op min :limit*retval *tmp68 ne_y
set .y :limit*retval
write :limit*retval memory 1
sensor *tmp21 switch1 @enabled
jump 64 equal *tmp21 false

143 lines of code

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

Program output (0 steps):

Compiler messages:

267 instructions before optimizations.
16 instructions eliminated by Temp Variables Elimination (2 passes, 6 iterations).
21 instructions eliminated by Dead Code Elimination (5 iterations).
3 instructions eliminated by Jump Normalization (2 passes, 5 iterations).
12 instructions eliminated by Jump Optimization (5 iterations).
14 instructions eliminated by Single Step Elimination (3 passes, 8 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 Optimization (3 iterations).
4 loops improved by Loop Optimization.
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 updated by Jump Threading.
1 instructions eliminated by Unreachable Code Elimination (2 iterations).
10 instructions eliminated by Print Merging.
143 instructions after optimizations.
Code size and number of instantiations by function: Size Times AvgSize Function 92 1x 92.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)
Performance: parsed in 43 ms, compiled in 8 ms, optimized in 108 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler