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";

// Creates a variable representing a Mindustry block linked as message1
linked message1;

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

51 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
jump 6 equal message1 null
sensor *tmp0 @unit @dead
op notEqual *tmp1 *tmp0 0
sensor *tmp2 @unit @controller
op notEqual *tmp3 *tmp2 @this
op or *tmp4 *tmp1 *tmp3
jump 25 equal *tmp4 false
op rand *tmp6 1000 0
ubind @poly
jump 19 notEqual @unit null
print "Drone mining\nNo unit of type poly found."
printflush messages
jump 14 always 0 0
sensor *tmp10 @unit @controlled
jump 24 equal *tmp10 0
print "Drone mining\nLooking for a free poly..."
printflush messages
jump 14 always 0 0
ucontrol flag *tmp6 0 0 0 0
sensor *tmp13 @unit @totalItems
ucontrol itemDrop @air *tmp13 0 0 0
sensor *tmp14 @unit @controller
op equal *tmp15 *tmp14 @this
sensor *tmp16 @unit @dead
op equal *tmp17 *tmp16 0
op land *tmp18 *tmp15 *tmp17
jump 0 equal *tmp18 false
print "Drone mining\n"
sensor *tmp19 @unit @totalItems
sensor *tmp20 @unit @itemCapacity
jump 41 greaterThanEq *tmp19 *tmp20
print "State: mining\n"
ucontrol approach patch_x patch_y 3 0 0
ucontrol mine patch_x patch_y 0 0 0
jump 47 always 0 0
print "State: dropping\n"
sensor *tmp23 container @x
sensor *tmp24 container @y
ucontrol approach *tmp23 *tmp24 3 0 0
sensor *tmp25 @unit @totalItems
ucontrol itemDrop container *tmp25 0 0 0
sensor *tmp26 @unit @itemCapacity
print "Unit capacity: "
print *tmp26
sensor *tmp27 @unit @totalItems
print "\nTotal items: "
print *tmp27
sensor *tmp28 @unit @firstItem
print "\nFirst item: "
print *tmp28
print "\n"
printflush message1
sensor *tmp14 @unit @controller
op equal *tmp15 *tmp14 @this
sensor *tmp16 @unit @dead
op equal *tmp17 *tmp16 0
op land *tmp18 *tmp15 *tmp17
jump 33 notEqual *tmp18 false

64 lines of code

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

Program output (0 steps):

Compiler messages:

93 instructions before optimizations.
10 instructions eliminated by Dead Code Elimination (4 iterations).
1 instructions eliminated by Jump Normalization (3 iterations).
3 instructions eliminated by Jump Optimization (3 iterations).
3 instructions eliminated by Single Step Elimination (2 passes, 5 iterations).
4 instructions eliminated by Data Flow Optimization (5 iterations).
5 instructions added by Loop Optimization (2 iterations).
1 loops improved by Loop Optimization.
3 instructions updated by JumpThreading.
1 instructions eliminated by Unreachable Code Elimination.
12 instructions eliminated by Print Merging.
64 instructions after optimizations.
Performance: parsed in 20 ms, compiled in 4 ms, optimized in 9 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler