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:

// Setting to use non-standard function mapping as described here:
// github.com/cardillan/mindcode/blob/main/doc/syntax/SYNTAX-4-FUNCTIONS.markdown#mindustry-logic-functions
#set target = ML7A;

// 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.

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

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

// Count the total number of upgraded blocks
TOTAL = 0;

allocate heap in MEMORY[0 ... 16];

// If a memory cell is attached, the progress can be stored there
// After resetting the processor, e.g. by modifying the unit type,
// we'll be able to pick up where we were stopped.
if $INITIALIZED then
    x = limit($X, SW_X, NE_X);
    y = limit($Y, SW_Y, NE_Y);
    dx = $DX == 1 ? 1 : -1;
    dy = $DY > 0 ? WIDTH : -WIDTH;
    TOTAL = $TOTAL;
else
    $INITIALIZED = true;
    x = $X = SW_X;
    y = $Y = SW_Y;
    dx = 1;
    dy = WIDTH;
end;

oldType = DOWNGRADE ? @titanium-conveyor : @conveyor;
newType = DOWNGRADE ? @conveyor : @titanium-conveyor;

// It is possible to pause/stop the processing by attaching a switch and activating it
// When the switch is active, the program renitializes 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
    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 yrep in y .. min(NE_Y, y + WIDTH - 1) do
        replace(x, yrep, oldType, newType);
    end;
    $TOTAL = TOTAL;

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);
        $DX = dx;

if y > NE_Y or y < SW_Y then
            dy = -dy;
            y = limit(y, SW_Y, NE_Y);
            $DY = dy;
        end;
        $Y = y;
    end;

$X = x;
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
def replace(x, y, oldType, newType)
    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);
        loop while type != newType;
        TOTAL += 1;
    end;
end;

133 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."
set __fn4__message message1
set MESSAGES null
print "Automatic conveyor upgrading\nTrying to locate message block"
set __fn4__n @links
jump 27 lessThanEq __fn4__n 0
op sub __fn4__n __fn4__n 1
getlink __fn4__block __fn4__n
print "\nFound: "
print __fn4__block
sensor __fn4__type __fn4__block @type
jump 26 notEqual @message __fn4__type
set MESSAGES __fn4__block
set __fn4__message __fn4__block
jump 18 greaterThan __fn4__n 0
print "\nMessage: "
print MESSAGES
printflush __fn4__message
set TOTAL 0
read __tmp15 MEMORY 0
jump 51 equal __tmp15 false
read __fn3_n MEMORY 1
op max __tmp79 __fn3_n SW_X
op min __fn3retval __tmp79 NE_X
set x __fn3retval
read __fn3_n MEMORY 2
op max __tmp79 __fn3_n SW_Y
op min __fn3retval __tmp79 NE_Y
set y __fn3retval
set dx -1
read __tmp21 MEMORY 3
jump 45 notEqual __tmp21 1
set dx 1
op mul dy -1 WIDTH
read __tmp24 MEMORY 4
jump 49 lessThanEq __tmp24 0
set dy WIDTH
read TOTAL MEMORY 5
jump 58 always 0 0
write true MEMORY 0
write SW_X MEMORY 1
set x SW_X
write SW_Y MEMORY 2
set y SW_Y
set dx 1
set dy WIDTH
set __tmp29 @conveyor
jump 61 equal DOWNGRADE false
set __tmp29 @titanium-conveyor
set oldType __tmp29
set __tmp30 @titanium-conveyor
jump 65 equal DOWNGRADE false
set __tmp30 @conveyor
set newType __tmp30
op idiv __tmp46 WIDTH 2
sensor __tmp31 switch1 @enabled
jump 149 notEqual __tmp31 false
sensor __tmp33 @unit @dead
op notEqual __tmp34 __tmp33 0
sensor __tmp35 @unit @controller
op notEqual __tmp36 __tmp35 @this
op or __tmp37 __tmp34 __tmp36
jump 93 equal __tmp37 false
op rand __tmp39 1000 0
ubind UNIT
jump 84 notEqual @unit null
print "Conveyor upgrading\n"
print "No unit of type "
print UNIT
print " found."
printflush MESSAGES
jump 76 always 0 0
sensor __tmp43 @unit @controlled
jump 92 equal __tmp43 0
print "Conveyor upgrading\n"
print "Looking for a free "
print UNIT
print "..."
printflush MESSAGES
jump 76 always 0 0
ucontrol flag __tmp39 0 0 0 0
op add __fn3_n y __tmp46
op max __tmp79 __fn3_n SW_Y
op min __fn3retval __tmp79 NE_Y
set ypos __fn3retval
ucontrol within x __fn3retval RADIUS __tmp49 0
jump 102 notEqual __tmp49 false
ucontrol move x __fn3retval 0 0 0
ucontrol within x __fn3retval RADIUS __tmp49 0
jump 99 equal __tmp49 false
op add __tmp51 y WIDTH
op sub __tmp52 __tmp51 1
op min __tmp54 NE_Y __tmp52
set yrep y
jump 116 greaterThan y __tmp54
ucontrol getBlock x yrep __fn6_type __fn6_building 0
jump 114 notEqual __fn6_type __tmp29
sensor __tmp60 __fn6_building @rotation
ucontrol build x yrep __tmp30 __tmp60 0
ucontrol getBlock x yrep __fn6_type 0 0
jump 111 notEqual __fn6_type __tmp30
op add TOTAL TOTAL 1
op add yrep yrep 1
jump 107 lessThanEq yrep __tmp54
write TOTAL MEMORY 5
print "Conveyor upgrading\nPosition: "
print x
print ", "
print __fn3retval
print "\nUpgrades: "
print TOTAL
print "\n"
printflush MESSAGES
op add x x dx
op greaterThan __tmp66 x NE_X
op lessThan __tmp67 x SW_X
op or __tmp68 __tmp66 __tmp67
jump 146 equal __tmp68 false
op mul dx -1 dx
op add y y dy
op max __tmp79 x SW_X
op min __fn3retval __tmp79 NE_X
set x __fn3retval
write dx MEMORY 3
op greaterThan __tmp73 y NE_Y
op lessThan __tmp74 y SW_Y
op or __tmp75 __tmp73 __tmp74
jump 145 equal __tmp75 false
op mul dy -1 dy
op max __tmp79 y SW_Y
op min __fn3retval __tmp79 NE_Y
set y __fn3retval
write dy MEMORY 4
write y MEMORY 2
write x MEMORY 1
sensor __tmp31 switch1 @enabled
jump 69 equal __tmp31 false
end
print "Compiled by Mindcode - github.com/cardillan/mindcode"

151 lines of code

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

Compiler messages:

Number of reported ambiguities: 17
277 instructions before optimizations.
23 instructions eliminated by Temp Variables Elimination.
23 instructions eliminated by Dead Code Elimination (4 iterations).
3 instructions eliminated by Jump Normalization (2 passes, 4 iterations).
12 instructions eliminated by Jump Optimization (4 iterations).
13 instructions eliminated by Single Step Elimination (3 passes, 7 iterations).
3 instructions eliminated by Expression Optimization (3 iterations).
2 instructions eliminated by If Expression Optimization (3 iterations).
34 instructions eliminated by Data Flow Optimization (4 passes, 17 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 (9 iterations).
3 loops unrolled by Loop Unrolling.
4 instructions eliminated by Function Inlining (9 iterations).
5 function calls inlined by Function Inlining.
2 instructions updated by JumpThreading.
2 instructions eliminated by Unreachable Code Elimination.
4 instructions eliminated by Print Merging.
150 instructions after optimizations.
Performance: parsed in 12 ms, compiled in 2 ms, optimized in 103 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler