Mindcode: a Mindustry Logic high-level language

Mindustry is a tower-defense type of game, now with added Logic. Logic is a programming language, but it is very low-level. It is more akin to assembly than high-level language.

Mindcode is a high-level language that compiles down to Mindustry Logic. Mindcode includes higher-level constructs, such as expressions, user-defined functions, control statements, or "direct" memory access.

Mindcode now comes with significantly improved code generation, including data flow analysis, loop unrolling and function inlining; for a list of recent changes, see changelog.

Mindcode Source Code: Mindustry Logic:

#set target = ML7A      // Using revised syntax for getBlock here

// Initialize variables first; these can be changed in the compiled code
MEMORY = cell1
UNIT = @poly

// Coordinates of the map area to process
// By default an entire map is converted
SW_X = 0
SW_Y = 0
NE_X = @mapw
NE_Y = @maph

// Setting to true restores copper conveyors (useful for testing)
DOWNGRADE = false

// Upgrading in stripes of given width -- faster processing
// (Could be even wider, the build radius is ~20 blocks or so)
WIDTH = 10

// How close unit needs to get to the block being upgraded
RADIUS = 10

// Count the total number of upgraded blocks
TOTAL = 0

allocate heap in MEMORY[0 ... 16]

// If a memory cell is attached, the progress can be stored there
if $INITIALIZED 
    x = limit($X, SW_X, NE_X)
    y = limit($Y, SW_Y, NE_Y)
    dx = $DX == 1 ? 1 : -1
    dy = $DY > 0 ? WIDTH : -WIDTH
    TOTAL = $TOTAL
else
    $INITIALIZED = true
    x = $X = SW_X
    y = $Y = SW_Y
    dx = 1
    dy = WIDTH
end

oldType = DOWNGRADE ? @titanium-conveyor : @conveyor
newType = DOWNGRADE ? @conveyor : @titanium-conveyor

// It is possible to pause/stop the processing
// by attaching a switch and activating it
while switch1.enabled == false

// If we don't have an active unit, summon a new one
    if @unit.dead !== 0 or @unit.controller != @this
        findUnit()
    end
    
    // Position the unit to the middle of the band
    ypos = limit(y + WIDTH \ 2, SW_Y, NE_Y)
    do 
        move(x, ypos)
    loop while not within(x, ypos, RADIUS)

// Upgrade all blocks in the band
    for yrep in y .. min(NE_Y, y + WIDTH - 1)
        replace(x, yrep, oldType, newType)
    end
    $TOTAL = TOTAL
    
    printf("Position: $x, $ypos\n")
    printf("Upgrades: $TOTAL")
    printflush(message1)
    
    // Move to next position
    x += dx
    if x > NE_X || x < SW_X
        dx *= -1
        y += dy
        x = limit(x, SW_X, NE_X)
        $DX = dx

if y > NE_Y || y < SW_Y
            dy *= -1
            y = limit(y, SW_Y, NE_Y)
            $DY = dy
        end
        $Y = y
    end
    
    $X = x
end

inline def findUnit()
    // Keep looking for unit until one is found
    while true
        ubind(UNIT)
        if @unit == null
            printf("No unit of type $UNIT found.")
        elsif @unit.controlled != 0
            printf("Looking for a free $UNIT...")
        else
            flag(1)		// Mark unit as active
            break
        end
        printflush(message1)
    end
end

// Returns value of n limited to range min .. max
inline def limit(n, min, max)
    min(max(n, min), max)
end

// If a block of type oldType is found at position,
// replaces it with newType
inline def replace(x, y, oldType, newType)
    b_building = getBlock(x, y, b_type)
    
    if b_type == oldType
        build(x, y, newType, b_building.rotation, 0)
        // If the processor is too fast, we need to wait
        // for the unit to finish building the block
        do
            getBlock(x, y, b_type)
        loop while b_type != newType
        TOTAL += 1
    end
end

126 lines of code

set MEMORY cell1
set UNIT @poly
set SW_X 0
set SW_Y 0
set NE_X @mapw
set NE_Y @maph
set DOWNGRADE false
set WIDTH 10
set RADIUS 10
set TOTAL 0
read __tmp0 MEMORY 0
jump 30 equal __tmp0 false
read __tmp2 MEMORY 1
op max __tmp4 __tmp2 SW_X
op min __tmp3 __tmp4 NE_X
set x __tmp3
read __tmp6 MEMORY 2
op max __tmp8 __tmp6 SW_Y
op min __tmp7 __tmp8 NE_Y
set y __tmp7
set dx -1
read __tmp10 MEMORY 3
jump 24 notEqual __tmp10 1
set dx 1
op mul dy -1 WIDTH
read __tmp13 MEMORY 4
jump 28 lessThanEq __tmp13 0
set dy WIDTH
read TOTAL MEMORY 5
jump 37 always 0 0
write true MEMORY 0
write SW_X MEMORY 1
set x SW_X
write SW_Y MEMORY 2
set y SW_Y
set dx 1
set dy WIDTH
set oldType @conveyor
jump 40 equal DOWNGRADE false
set oldType @titanium-conveyor
set newType @titanium-conveyor
jump 43 equal DOWNGRADE false
set newType @conveyor
op idiv __tmp35 WIDTH 2
sensor __tmp20 switch1 @enabled
jump 122 notEqual __tmp20 false
sensor __tmp22 @unit @dead
op strictEqual __tmp23 __tmp22 0
op equal __tmp24 __tmp23 false
sensor __tmp25 @unit @controller
op notEqual __tmp26 __tmp25 @this
op or __tmp27 __tmp24 __tmp26
jump 69 equal __tmp27 false
ubind UNIT
jump 59 notEqual @unit null
print "No unit of type "
print UNIT
print " found."
jump 67 always 0 0
sensor __tmp32 @unit @controlled
jump 65 equal __tmp32 0
print "Looking for a free "
print UNIT
print "..."
jump 67 always 0 0
ucontrol flag 1 0 0 0 0
jump 69 always 0 0
printflush message1
jump 53 always 0 0
op add __tmp36 y __tmp35
op max __tmp38 __tmp36 SW_Y
op min __tmp37 __tmp38 NE_Y
set ypos __tmp37
ucontrol move x __tmp37 0 0 0
ucontrol within x __tmp37 RADIUS __tmp40 0
jump 73 equal __tmp40 false
op add __tmp42 y WIDTH
op sub __tmp43 __tmp42 1
op min __tmp45 NE_Y __tmp43
set yrep y
jump 90 greaterThan y __tmp45
ucontrol getBlock x yrep __fn4_b_type __fn4_b_building __tmp48
jump 88 notEqual __fn4_b_type oldType
sensor __tmp51 __fn4_b_building @rotation
ucontrol build x yrep newType __tmp51 0
ucontrol getBlock x yrep __fn4_b_type __tmp52 __tmp53
jump 85 notEqual __fn4_b_type newType
op add TOTAL TOTAL 1
op add yrep yrep 1
jump 81 lessThanEq yrep __tmp45
write TOTAL MEMORY 5
print "Position: "
print x
print ", "
print __tmp37
print "\nUpgrades: "
print TOTAL
printflush message1
op add x x dx
op greaterThan __tmp57 x NE_X
op lessThan __tmp58 x SW_X
op or __tmp59 __tmp57 __tmp58
jump 119 equal __tmp59 false
op mul dx dx -1
op add y y dy
op max __tmp64 x SW_X
op min __tmp63 __tmp64 NE_X
set x __tmp63
write dx MEMORY 3
op greaterThan __tmp66 y NE_Y
op lessThan __tmp67 y SW_Y
op or __tmp68 __tmp66 __tmp67
jump 118 equal __tmp68 false
op mul dy dy -1
op max __tmp72 y SW_Y
op min __tmp71 __tmp72 NE_Y
set y __tmp71
write dy MEMORY 4
write y MEMORY 2
write x MEMORY 1
sensor __tmp20 switch1 @enabled
jump 46 equal __tmp20 false
end

123 lines of code

Start with a new script Enable optimization

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

Compiler messages:

193 instructions before optimizations.
14 instructions eliminated by Temp Variables Elimination.
16 instructions eliminated by Dead Code Elimination (4 iterations).
1 instructions eliminated by Jump Normalization (4 iterations).
8 instructions eliminated by Jump Optimization (4 iterations).
8 instructions eliminated by Single Step Elimination (2 passes, 6 iterations).
4 instructions eliminated by If Expression Optimization (3 iterations).
19 instructions eliminated by Data Flow Optimization (2 passes, 7 iterations).
1 loops improved by Loop Hoisting.
1 instructions added by Loop Optimization (3 iterations).
2 loops improved by Loop Optimization.
1 instructions eliminated by Print Merging.
123 instructions after optimizations.
Performance: parsed in 154 ms, compiled in 10 ms, optimized in 131 ms.

Mindcode compiler Schematics Builder Schematics Decompiler

Mindcode compiler
Schematics Builder
Schematics Decompiler