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:

// Units is a system library providing functions for easy acquisition of units
require units;

// These assignments will be compiled into the output code as-is.
// It is possible to change them in the compiled code.

/// Configurable options:
param container = vault1;
param patch_x = 16;
param patch_y = 17;
param messages = message1;

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

begin
    // Find a unit if we don't have one
    if @unit.@dead != 0 or @unit.@controller != @this then
        // 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.
        waitForFreeUnit(messages, title, @poly, rand(1000));
    end;

// Throw away anything the unit might have been carrying
    itemDrop(@air, @unit.@totalItems);

// Mine until the unit is lost or killed
    // Then the program restarts, acquiring another unit
    while @unit.@controller == @this and @unit.@dead == 0 do
        print(title);

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(messages);
    end;
end;

48 lines of code

jump 2 always 0 0
print "Configurable options:"
set container vault1
set patch_x 16
set patch_y 17
set messages message1
sensor *tmp0 @unit @dead
jump 10 notEqual *tmp0 0
sensor *tmp2 @unit @controller
jump 22 equal *tmp2 @this
op rand *tmp5 1000 0
ubind @poly
jump 16 notEqual @unit null
print "Drone mining\nNo unit of type poly found."
printflush messages
jump 11 always 0 0
sensor *tmp9 @unit @controlled
jump 21 equal *tmp9 0
print "Drone mining\nLooking for a free poly..."
printflush messages
jump 11 always 0 0
ucontrol flag *tmp5 0 0 0 0
sensor *tmp12 @unit @totalItems
ucontrol itemDrop @air *tmp12 0 0 0
sensor *tmp13 @unit @controller
jump 0 notEqual *tmp13 @this
sensor *tmp15 @unit @dead
jump 0 notEqual *tmp15 0
print "Drone mining\n"
sensor *tmp17 @unit @totalItems
sensor *tmp18 @unit @itemCapacity
jump 36 greaterThanEq *tmp17 *tmp18
print "State: mining\n"
ucontrol approach patch_x patch_y 3 0 0
ucontrol mine patch_x patch_y 0 0 0
jump 42 always 0 0
print "State: dropping\n"
sensor *tmp21 container @x
sensor *tmp22 container @y
ucontrol approach *tmp21 *tmp22 3 0 0
sensor *tmp23 @unit @totalItems
ucontrol itemDrop container *tmp23 0 0 0
sensor *tmp24 @unit @itemCapacity
print "Unit capacity: "
print *tmp24
sensor *tmp25 @unit @totalItems
print "\nTotal items: "
print *tmp25
sensor *tmp26 @unit @firstItem
print "\nFirst item: "
print *tmp26
print "\n"
printflush messages
sensor *tmp13 @unit @controller
jump 26 equal *tmp13 @this

55 lines of code

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

Program output (0 steps):

Compiler messages:

94 instructions before optimizations.
10 instructions eliminated by Dead Code Elimination (6 iterations).
1 instructions eliminated by Jump Normalization (5 iterations).
7 instructions eliminated by Condition Optimization (6 iterations).
4 instructions eliminated by Single Step Elimination (3 passes, 8 iterations).
4 instructions eliminated by Data Flow Optimization (5 iterations).
1 instructions added by Loop Rotation (2 iterations).
1 loop conditions were partially rotated.
1 instructions eliminated by Jump Straightening (6 iterations).
4 instructions updated by Jump Threading.
1 instructions eliminated by Unreachable Code Elimination (3 iterations).
12 instructions eliminated by Print Merging.
55 instructions after optimizations.
Code size and number of instantiations by function: Size Times AvgSize Function 44 1x 44.0 <no function> 11 1x 11.0 def waitForFreeUnit(in message, in preface, in unit_type, in initial_flag)
Size: 55 instructions, performance: parsed in 19 ms, compiled in 3 ms, optimized in 9 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler