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

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

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

38 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 30 equal __tmp4 false
ubind UNIT
jump 21 notEqual @unit null
print "Healing damaged buildings\n"
print "No unit of type "
print UNIT
print " found."
printflush MESSAGES
jump 13 always 0 0
sensor __tmp9 @unit @controlled
jump 29 equal __tmp9 0
print "Healing damaged buildings\n"
print "Looking 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 __tmp12 0
jump 41 equal __tmp12 false
print "Healing damaged buildings\n"
print "Found 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 52 always 0 0
print "Healing damaged buildings\n"
print "Patrolling\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
end
print "Compiled by Mindcode - github.com/cardillan/mindcode"

55 lines of code

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

Compiler messages:

Number of reported ambiguities: 5
75 instructions before optimizations.
1 instructions modified by Temp Variables Elimination.
10 instructions eliminated by Dead Code Elimination (4 iterations).
1 instructions eliminated by Jump Normalization (3 iterations).
2 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 (4 iterations).
2 instructions updated by JumpThreading.
1 instructions eliminated by Unreachable Code Elimination.
1 instructions eliminated by Print Merging.
54 instructions after optimizations.
Performance: parsed in 5 ms, compiled in 2 ms, optimized in 6 ms.

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler