Mindcode: a Mindustry Logic high-level language

Here you can compile a schematics definition written in Schemacode, a schema definition language, into a text representation to be pasted into Mindustry using the Import schematics... button. If your schematics contain processors, you can specify code for the processor using either Mindustry Logic or Mindcode. You can also decompile an existing schematics using the Decompiler and modify the resulting code.

Schemacode definition: Encoded schematic:

schematic
    name = "Instant Overdrive Dome"
    description = """
        Uses units to supply the projector with silicone and phase fabric from the core.
        The preferred unit type can be set in the UNIT_TYPE.
        If units of this type are  not available, the processor tries to use
        flare, poly, mega or mono (in this order) until a suitable unit is found.

Once the preferred unit becomes available, the processor switches to that unit.

If units used by the processor are lost (either stolen by another processor or by player,
        or destroyed), the program is restarted and new units, possibly of different type again,
        are acquired.

If the type of servicing units is too slow to travel to the core and back before the overdrive
        dome consumes all its items, two pairs of units are used to ensure continuous operation.

Use switch to activate/deactivate supply.
        """

dome1:
    @overdrive-dome      at ( 0,  0)
message1:
    @message             at ( 1,  3)
switch1:
    @switch              at ( 2,  3) enabled
    @micro-processor     at ( 0,  3) processor
        links
            dome1 as dome1
            message1 as message1
            switch1 as switch1
        end
        mindcode = program
    end
end

program = """
    // Instant Overdrive Dome
    // Unit transport of silicon or phase fabric to overdrive dome using two (or four) units

// Note: to speed up compilation a bit, all functions are declared inline,
    // because we know the compiled code fits into the instruction limit.
    // Furthermore the instruction limit is raised to allow all loops to get unrolled.
    // Optimization then brings the number of instruction back under 1000.

#set instruction-limit  = 1100;
    #set target = ML7A;                 // Using revised syntax for ulocate

/// This is the preferred unit type to use for bringing in supplies.
    /// If no units of this type exist, we'll try using other types.
    param UNIT_TYPE         = @flare;  // Which unit to use

/// Do not modify anything below this line.

// BASIC INITIALIZATION
    /////////////////////////////////////////////////////////
    const RADIUS_WITHIN     = 8;
    const RADIUS_APPROACH   = 6;

const S_UNUSED          = 0;        // Unit is not used.
    const S_INIT            = 1;        // Unloading wrong items held by unit/initializing unit
    const S_APPROACH_SRC    = 2;        // Approaching source block
    const S_APPROACH_DST    = 3;        // Approaching destination block

// How long it takes for Overdrive Dome to use up all supplies (sec). Subtract three for safety.
    const SUPPLY_INTERVAL   = 50 - 3;

// Interval to check for the availability of the optimal unit type if not used
    const UNIT_CHECK_TIME   = 5000;

// FIND DOME
    // Now this is funny: the processor might get built way
    // earlier than the dome and miss it in initialization
    /////////////////////////////////////////////////////////
    DOME = dome1;
    while DOME == null do
        print("[gold]Waiting for an overdrive dome to be connected...");
        printflush(message1);
        DOME = dome1;
    end;

// ACTIVATION SWITCH
    /////////////////////////////////////////////////////////
    while not switch1.@enabled do
        println("[coral]Activate switch to begin supplying overdrive dome...");
        printflush(message1);
    end;

// FIND AVAILABLE UNIT TYPE
    /////////////////////////////////////////////////////////
    TYPE = chooseUnitType();

// BASIC INITIALIZATION - REBINDING UNIT
    /////////////////////////////////////////////////////////
    print($"[gold]Binding units...");
    printflush(message1);
    rebindUnits();

// First set of units is always needed
    UNIT_S1 = acquireUnit(UNIT_S1);
    UNIT_P1 = acquireUnit(UNIT_P1);

if UNIT_S1.@firstItem == @phase-fabric or UNIT_P1.@firstItem == @silicon then
        // At least one of our units holds wrong item. Swapping them fixes at least one
        u = UNIT_S1;
        UNIT_S1 = UNIT_P1;
        UNIT_P1 = u;
    end;

// GATHERING STATISTICS
    /////////////////////////////////////////////////////////
    UNIT_CAPACITY = UNIT_S1.@itemCapacity;
    SPEED = UNIT_S1.@speed;
    SPEED_TENTHS = SPEED / 10;

if SPEED === null then
        stopProcessor();
    end;

print("[gold]Locating core...");
    printflush(message1);
    do
        CORE = ulocate(building, core, false);
    loop while CORE == null;

CORE_X = CORE.@x;
    CORE_Y = CORE.@y;
    DOME_X = DOME.@x;
    DOME_Y = DOME.@y;

FOUR_UNITS = needsFourUnits(UNIT_S1);

if FOUR_UNITS then
        UNIT_S2 = acquireUnit(UNIT_S2);
        UNIT_P2 = acquireUnit(UNIT_P2);

if UNIT_S1.@firstItem == @phase-fabric and UNIT_P2.@firstItem != @phase-fabric then
            // At least one of our units holds wrong item. Swapping them fixes at least one
            u = UNIT_S1;
            UNIT_S1 = UNIT_P2;
            UNIT_P2 = u;
        end;

if UNIT_S2.@firstItem == @phase-fabric or UNIT_P2.@firstItem == @silicon then
            // At least one of our units holds wrong item. Swapping them fixes at least one
            u = UNIT_S2;
            UNIT_S2 = UNIT_P2;
            UNIT_P2 = u;
        end;

GROUP1 = "unit  1";
        GROUP2 = "unit 2";
    else
        ubind(UNIT_S2); unbind(); UNIT_S2 = null;
        ubind(UNIT_P2); unbind(); UNIT_P2 = null;
        GROUP1 = "unit";
    end;

SUPPLY_S_FIRST = not FOUR_UNITS or UNIT_S1.@totalItems < UNIT_S2.@totalItems;
    SUPPLY_P_FIRST = not FOUR_UNITS or UNIT_P1.@totalItems < UNIT_P2.@totalItems;

unitCheck = @time + UNIT_CHECK_TIME;

// MAIN LOOP
    /////////////////////////////////////////////////////////
    while switch1.@enabled do
        start = @time;
        println(" === [gold]Supplying Overdrive Dome[] === ");
        println($"\nUnit type: [green]$TYPE[]");

// Note: processUnit rebinds a unit if it is lost. Store it back
        printDomeStatus(@silicon, "\n[green]Silicon[] status:\n");
        UNIT_S1 = processUnit(UNIT_S1, @silicon, GROUP1, SUPPLY_S_FIRST);
        if FOUR_UNITS then
            UNIT_S2 = processUnit(UNIT_S2, @silicon, GROUP2, not SUPPLY_S_FIRST);
            SUPPLY_S_FIRST = SUPPLY_S_FIRST ? UNIT_S1.@totalItems > 0 : UNIT_S2.@totalItems == 0;
        end;

printDomeStatus(@phase-fabric, "\n[green]Phase fabric[] status:\n");
        UNIT_P1 = processUnit(UNIT_P1, @phase-fabric, GROUP1, SUPPLY_P_FIRST);
        if FOUR_UNITS then
            UNIT_P2 = processUnit(UNIT_P2, @phase-fabric, GROUP2, not SUPPLY_P_FIRST);
            SUPPLY_P_FIRST = SUPPLY_P_FIRST ? UNIT_P1.@totalItems > 0 : UNIT_P2.@totalItems == 0;
        end;

print($"\n[lightgray]Loop time: $ ms", floor(@time - start));
        printflush(message1);

if TYPE != UNIT_TYPE and unitCheck > @time then
            if areUnitsAvailable(UNIT_TYPE, false) then
                end();
            end;
            unitCheck = @time + UNIT_CHECK_TIME;
        end;
    end;

// Determines how many units of given type are needed to service this dome
    inline def needsFourUnits(unit)
        // Compute the time it takes to travel to the core and back
        travel_time = 2 * len(DOME_X - CORE_X, DOME_Y - CORE_Y) / unit.@speed;

// Do we need a backup set of units?
        return travel_time >= SUPPLY_INTERVAL;
    end;

// Chooses a type of units to use - the first type of which there are enough free units
    inline def chooseUnitType()
        while true do
            printflush(null);       // empty text buffer
            println("[gold]Looking for suitable unit type:[]");
            if areUnitsAvailable(UNIT_TYPE, true) then
                return UNIT_TYPE;
            end;

for type in @flare, @poly, @mega, @mono do
                if type != UNIT_TYPE then
                    if areUnitsAvailable(type, true) then
                        printflush(null);
                        return type;
                    end;
                end;
            end;
            printflush(message1);
        end;
    end;

// This method determines whether there are enough free units of given type to use
    // We may need two or four of them, depending on unit speed and the distance to the core
    inline def areUnitsAvailable(type, output)
        free = occupied = needed = 0;
        firstUnit = ubind(type);
        if firstUnit != null then
            needed = needsFourUnits(@unit) ? 4 : 2;
            do
                if @unit.@controlled == 0 || @unit.@controller == @this then
                    if (free += 1) >= needed then
                        return true;
                    end;
                else
                    occupied += 1;
                end;
                ubind(type);
            loop while @unit != firstUnit and firstUnit.@dead == 0;
        end;

if output then
            print($"$type: occupied: $occupied, free: $free");
            if needed > 0 then print($", needed: $needed"); end;
            println();
        end;

return false;
    end;

// Tries to bind again units which have been controlled by this processor recently
    // If the switch is turned off and then on again quickly, we might find our last
    // units still having the supplies on them
    inline def rebindUnits()
        UNIT_S1 = UNIT_P1 = UNIT_S2 = UNIT_P2 = null;
        count = 0;

firstUnit = ubind(TYPE);
        if firstUnit == null then
            // We had at least one unit of this type, but it got lost.
            // Reinitialize all to determine available unit type
            end();
        end;

// We have a unit as a reference. Try to find unit owned by us
        do
            if @unit.@controller == @this then
                count += 1;
                flag(S_INIT);
                UNIT_S2 = UNIT_P2;
                UNIT_P2 = UNIT_S1;
                UNIT_S1 = UNIT_P1;
                UNIT_P1 = @unit;
                if UNIT_S2 != null then
                    break;
                end;
            end;
            ubind(TYPE);
        loop while @unit != firstUnit and firstUnit.@dead == 0;
        return count;
    end;

// Rebinds a unit that was in use, or acquires a new one
    // If no unit can be acquired, reinitializes everything to get units of different type
    inline def rebindUnit(currentUnit)
        if currentUnit != null then
            ubind(currentUnit);
            if @unit.@dead === 0 && @unit.@controller == @this then
                // Current unit is valid, no need to rebind
                return currentUnit;
            end;
        end;

// We need to find an uncontrolled unit - either we're initializing, or lost one
        firstUnit = ubind(TYPE);
        if firstUnit != null then
            do
                if @unit.@controlled == 0 then
                    return @unit;
                end;
                ubind(TYPE);
            loop while @unit != firstUnit and firstUnit.@dead == 0;
        end;

// No additional unit of this type is available - reinitialize
        end();
    end;

inline def acquireUnit(currentUnit)
        rebindUnit(currentUnit);
        flag(S_INIT);
        return @unit;
    end;

// Controls one unit
    inline def processUnit(unit, item, group, supply)
        rebindUnit(unit);

// We have a bound, functioning unit
        state = @unit.@flag;
        distance = -1;
        color = "gold";

// Initializes the unit if not in a known state
        if state < S_APPROACH_SRC or state > S_APPROACH_DST then
            if @unit.@firstItem == item then
                // We've got what we need, bring the supplies in!
                // Jump threading optimization here...
                state = S_APPROACH_DST;
            elsif @unit.@totalItems == 0 then
                // We're empty, resupply
                // Jump threading optimization here...
                state = S_APPROACH_SRC;
            else
                // Get rid of whatever we might be carrying right now
                MSG = ", initializing\n";
                approach(CORE_X, CORE_Y, RADIUS_APPROACH);
                if within(CORE_X, CORE_Y, RADIUS_WITHIN) then
                    itemDrop(CORE, UNIT_CAPACITY);
                end;
            end;
        end;

if state == S_APPROACH_SRC then
            if within(CORE_X, CORE_Y, RADIUS_WITHIN) then
                itemTake(CORE, item, UNIT_CAPACITY);
                if @unit.@totalItems >= UNIT_CAPACITY then
                    approach(DOME_X, DOME_Y, RADIUS_APPROACH);
                    // Jump threading optimization here...
                    state = S_APPROACH_DST;
                else
                    MSG = ", loading\n";
                end;
            else
                approach(CORE_X, CORE_Y, RADIUS_APPROACH);
                MSG = ", fetching in [gold]";
                distance = len(CORE_X - @unit.@x, CORE_Y - @unit.@y) \ SPEED_TENTHS / 10;
            end;
        end;

if state == S_APPROACH_DST then
            if within(DOME_X, DOME_Y, RADIUS_WITHIN) then
                if supply then
                    itemDrop(DOME, UNIT_CAPACITY);
                    MSG = ", supplying\n";
                    //color = "green";
                else
                    approach(DOME_X, DOME_Y, RADIUS_APPROACH);   // Keep the unit active
                    MSG = ", waiting\n";
                end;
                if @unit.@totalItems <= 0 then
                    approach(CORE_X, CORE_Y, RADIUS_APPROACH);
                    state = S_APPROACH_SRC;
                end;
            else
                approach(DOME_X, DOME_Y, RADIUS_APPROACH);
                MSG = ", returning in [gold]";
                distance = len(DOME_X - @unit.@x, DOME_Y - @unit.@y) \ SPEED_TENTHS / 10;
            end;
        end;

flag(state);

print($"  $group: [$color]$[]", @unit.@totalItems);
        if distance >= 0 then
            println($"$MSG$distance[] sec");
        else
            print(MSG);
        end;

return @unit;
    end;

inline def printDomeStatus(item, text)
        print(text);
        level = DOME.sensor(item);
        if level > 3 then
            println($"  dome:  [green]$[]", level);
        else
            println($"  dome:  [coral]$[]", level);
        end;
    end;
    """

407 lines of code

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

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

Build messages:

Compiling embedded code
Number of reported ambiguities: 96
1399 instructions before optimizations.
59 instructions eliminated by Temp Variables Elimination.
252 instructions eliminated by Dead Code Elimination (6 iterations).
6 instructions eliminated by Jump Normalization (2 passes, 5 iterations).
75 instructions eliminated by Jump Optimization (2 passes, 5 iterations).
108 instructions eliminated by Single Step Elimination (3 passes, 8 iterations).
2 instructions eliminated by If Expression Optimization (4 iterations).
69 instructions eliminated by Data Flow Optimization (2 passes, 12 iterations).
2 instructions added by Loop Optimization (4 iterations).
3 loops improved by Loop Optimization.
157 instructions added by Loop Unrolling (7 iterations).
1 loops unrolled by Loop Unrolling.
17 instructions eliminated by Jump Straightening (5 iterations).
24 instructions updated by JumpThreading.
16 instructions eliminated by Unreachable Code Elimination.
26 instructions eliminated by Print Merging.
928 instructions after optimizations.
Performance: parsed in 1,975 ms, compiled in 55 ms, optimized in 1,633 ms.
Created schematic 'Instant Overdrive Dome' with dimensions ( 3, 4).

Mindcode Compiler Mlog Decompiler Schematics Builder Schematics Decompiler

Mindcode Compiler
Mlog Decompiler
Schematics Builder
Schematics Decompiler