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:

// These assignments will be compiled into the output code as-is.
// It is possible to change them in the compiled code.
param CONTAINER = vault1;
param PATCH_X = 16;
param PATCH_Y = 17;

// Find a live unit (@unit.dead === 0) that is not controlled
// by a player or processor (@unit.controlled == 0)
do
    print("Searching available unit...");
    printflush(message1);
    ubind(@poly);
loop while (@unit.dead !== 0) or (@unit.controlled != 0);

// Some Mindustry code on the internet relies on nonzero flag
// marking used units. Assign non-zero flag to protect our unit
// from such code run by other processors.
flag(rand(1000));

// Mine until the unit is lost or killed
// Then the program restarts, acquiring another unit
while (@unit.controller == @this) and (@unit.dead === 0) do
    if @unit.totalItems < @unit.itemCapacity then
        println("State: mining");
        approach(PATCH_X, PATCH_Y, 3);
        mine(PATCH_X, PATCH_Y);
    else
        println("State: dropping");
        approach(CONTAINER.x, CONTAINER.y, 3);
        itemDrop(CONTAINER, @unit.totalItems);
    end;

println("Unit capacity: ", @unit.itemCapacity);
    println("Total items: ", @unit.totalItems);
    println("First item: ", @unit.firstItem);
    printflush(message1);
end;

37 lines of code

set CONTAINER vault1
set PATCH_X 16
set PATCH_Y 17
print "Searching available unit..."
printflush message1
ubind @poly
sensor __tmp0 @unit @dead
op strictEqual __tmp1 __tmp0 0
op equal __tmp2 __tmp1 false
sensor __tmp3 @unit @controlled
op notEqual __tmp4 __tmp3 0
op or __tmp5 __tmp2 __tmp4
jump 3 notEqual __tmp5 false
op rand __tmp6 1000 0
ucontrol flag __tmp6 0 0 0 0
sensor __tmp7 @unit @controller
op equal __tmp8 __tmp7 @this
sensor __tmp9 @unit @dead
op strictEqual __tmp10 __tmp9 0
op land __tmp11 __tmp8 __tmp10
jump 51 equal __tmp11 false
sensor __tmp12 @unit @totalItems
sensor __tmp13 @unit @itemCapacity
jump 28 greaterThanEq __tmp12 __tmp13
print "State: mining\n"
ucontrol approach PATCH_X PATCH_Y 3 0 0
ucontrol mine PATCH_X PATCH_Y 0 0 0
jump 34 always 0 0
print "State: dropping\n"
sensor __tmp16 CONTAINER @x
sensor __tmp17 CONTAINER @y
ucontrol approach __tmp16 __tmp17 3 0 0
sensor __tmp18 @unit @totalItems
ucontrol itemDrop CONTAINER __tmp18 0 0 0
sensor __tmp19 @unit @itemCapacity
print "Unit capacity: "
print __tmp19
sensor __tmp20 @unit @totalItems
print "\nTotal items: "
print __tmp20
sensor __tmp21 @unit @firstItem
print "\nFirst item: "
print __tmp21
print "\n"
printflush message1
sensor __tmp7 @unit @controller
op equal __tmp8 __tmp7 @this
sensor __tmp9 @unit @dead
op strictEqual __tmp10 __tmp9 0
op land __tmp11 __tmp8 __tmp10
jump 21 notEqual __tmp11 false
end
print "Compiled by Mindcode - github.com/cardillan/mindcode"

53 lines of code

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

Compiler messages:

Number of reported ambiguities: 20
54 instructions before optimizations.
2 instructions eliminated by Dead Code Elimination (3 iterations).
1 instructions eliminated by Jump Optimization (3 iterations).
5 instructions added by Loop Optimization (2 iterations).
1 loops improved by Loop Optimization.
4 instructions eliminated by Print Merging.
52 instructions after optimizations.
Performance: parsed in 57 ms, compiled in 2 ms, optimized in 5 ms.

Mindcode compiler Schematics Builder Schematics Decompiler

Mindcode compiler
Schematics Builder
Schematics Decompiler