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:

// Patrols around a building and heals any damaged building
// Since the patrolling ship is close by, repairing will happen faster than usual

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

// This part of the script will create mlog variables which can be modified
// in the compiled code to change which unit to use and which building to circle around
// The following line is a special comment which will be written to the mlog code as well.

/// Configurable options:
param CENTER = foundation1;
param UNIT = @poly;

// We'll write messages onto this block
// It is used by the units system library to output messages as well
param MESSAGES = message1;

/// Don't modify anything below this line.

// Title printed to messages to help identify the processor purpose
const TITLE = "Healing damaged buildings\n";

begin
    // Find a unit if we don't have one
    if @unit.@dead != 0  or @unit.@controller != @this then
        waitForFreeUnit(MESSAGES, TITLE, UNIT, 1);
    end;

var dmgx, dmgy;
    if ulocate(:damaged, out dmgx, out dmgy) then
        println($"${TITLE}Found damaged block at $dmgx, $dmgy");
        approach(dmgx, dmgy, 5);
        target(dmgx, dmgy, true);
    else
        println(TITLE, "Patrolling");
        approach(CENTER.@x + 10 * sin(@tick), CENTER.@y + 10 * cos(@tick), 2);
    end;

printflush(MESSAGES);
end;

40 lines of code

jump 2 always 0 0
print "Configurable options:"
set CENTER foundation1
set UNIT @poly
set MESSAGES message1
jump 7 always 0 0
print "Don't modify anything below this line."
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
ubind UNIT
jump 20 notEqual @unit null
print "Healing damaged buildings\nNo unit of type "
print UNIT
print " found."
printflush MESSAGES
jump 13 always 0 0
sensor *tmp9 @unit @controlled
jump 27 equal *tmp9 0
print "Healing damaged buildings\nLooking for a free "
print UNIT
print "..."
printflush MESSAGES
jump 13 always 0 0
ucontrol flag 1 0 0 0 0
ulocate damaged core true @copper :dmgx :dmgy 0 *tmp12
jump 38 equal *tmp12 false
print "Healing damaged buildings\nFound damaged block at "
print :dmgx
print ", "
print :dmgy
print "\n"
ucontrol approach :dmgx :dmgy 5 0 0
ucontrol target :dmgx :dmgy true 0 0
jump 48 always 0 0
print "Healing damaged buildings\nPatrolling\n"
sensor *tmp15 CENTER @x
op sin *tmp16 @tick 0
op mul *tmp17 10 *tmp16
op add *tmp18 *tmp15 *tmp17
sensor *tmp19 CENTER @y
op cos *tmp20 @tick 0
op mul *tmp21 10 *tmp20
op add *tmp22 *tmp19 *tmp21
ucontrol approach *tmp18 *tmp22 2 0 0
printflush MESSAGES

49 lines of code

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

Program output (0 steps):

Compiler messages:

78 instructions before optimizations.
1 instructions modified by Temp Variables Elimination.
10 instructions eliminated by Dead Code Elimination (5 iterations).
1 instructions eliminated by Jump Normalization (4 iterations).
2 instructions eliminated by Jump Optimization (4 iterations).
3 instructions eliminated by Single Step Elimination (2 passes, 6 iterations).
4 instructions eliminated by Data Flow Optimization (4 iterations).
2 instructions updated by JumpThreading.
1 instructions eliminated by Unreachable Code Elimination (2 iterations).
8 instructions eliminated by Print Merging.
49 instructions after optimizations.
Performance: parsed in 19 ms, compiled in 4 ms, optimized in 4 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler