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

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

46 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
op notEqual __tmp1 __tmp0 0
sensor __tmp2 @unit @controller
op notEqual __tmp3 __tmp2 @this
op or __tmp4 __tmp1 __tmp3
jump 28 equal __tmp4 false
op rand __tmp6 1000 0
ubind @poly
jump 20 notEqual @unit null
print "Drone mining\nNo unit of type "
print @poly
print " found."
printflush MESSAGES
jump 13 always 0 0
sensor __tmp10 @unit @controlled
jump 27 equal __tmp10 0
print "Drone mining\nLooking for a free "
print @poly
print "..."
printflush MESSAGES
jump 13 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 67 equal __tmp18 false
print "Drone mining\n"
sensor __tmp19 @unit @totalItems
sensor __tmp20 @unit @itemCapacity
jump 44 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 50 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 36 notEqual __tmp18 false
end
print "Compiled by Mindcode - github.com/cardillan/mindcode"

69 lines of code

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

Compiler messages:

Main file: number of reported ambiguities: 6
90 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).
2 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.
2 instructions updated by JumpThreading.
1 instructions eliminated by Unreachable Code Elimination.
6 instructions eliminated by Print Merging.
68 instructions after optimizations.
Performance: parsed in 1,023 ms, compiled in 76 ms, optimized in 91 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler