Mindcode uses Mindustry Logic processor variables for its own variables. These variables can contain a number (integer or real), an object, or a null value. An object can be a Mindustry object, such as a block or a unit, a Mindustry constant such as @coal, or a string such as "Text".
Variables aren't declared in Mindcode, they're created with first use. count = 10 creates a variable named count and assigns a value of 10 to it. Variables that weren't previously written to have a value of null in Mindustry Logic. Once set, processor variables are preserved (even across game saves/loads) until the processor code is modified or the processor is destroyed.
Important
Mindustry Logic stores numbers as double, a 64-bit floating point value. To perform bitwise operations, such as & or <<, the value is converted to a 64-bit integer (a Java long), the operation is performed and the result is assigned to a double again. As a consequence, for bitwise operations the variables are able to hold only about 52 bits or so.
Mindcode is aware of the actual values you assign to variables. In some cases, knowing the actual value allows specific code optimizations to be performed, which are only valid for the value you've assigned to the variable in the source code (see Data Flow Optimization). Therefore, changing a value assigned to a variable in the compiled code might not produce the same results as changing the assigned value in the source code. For example, the following code:
min = 0;
max = 10;
func(min, max);
while min < max do
println(min);
min += 1;
max -= 1;
end;
def func(min, max)
println(max - min > 5 ? "High" : "Low");
end;
compiles into
set min 0
set max 10
print "High\n"
print min
print "\n"
op add min min 1
op sub max max 1
jump 3 lessThan min max
end
Setting min to 10 in the source code would cause the function to output Low instead of High. However, as is obvious from the compiled code, the function has been optimized in such a way that it always prints High, based on the values of the min and max variables present in the source code.
Mindcode has a specific mechanism for allowing program parametrization, that is changing some values assigned to variables in the compiled code. Such values must be declared as program parameters, as described below.
Main variables are variables used in the main body of the program. The name of the variable in Mindcode is used as-is in the compiled mlog code.
Local variables are function parameters or variables used in a user-defined function. For example, in a function
def foo(x)
y = x ** 2;
end;
both x and y are local variables, not accessible outside the function foo.
In compiled code, names of these variables are appended to a unique function prefix. Recognizing names of local variables in compiled code might be a bit cumbersome.
Global variables are common to all user functions and the main program body. Use names that don't contain any lowercase letters, such as MAIN or _9 (this is actually not a particularly good name for a variable), to create global variables. Variables whose name contains at least one lowercase letter are not global.
For example, the following code
def foo(x)
MAIN = x + 10;
local = 10;
end;
MAIN = 5;
local = 5;
x = 0;
foo(10);
print(MAIN, ", ", local);
printflush(message1);
displays 20, 5 on the message1 block in Mindustry world, since both x and local in the foo function are local variables and therefore distinct from x and local in the main program body.
Using global variables as function parameters (e.g. def foo(Z) ... end) is not allowed.
Important
In previous versions of Mindcode, global variables also served as program parameters described below. This usage of global variables will cease to be supported be removed in a future release. Please modify your programs to use program parameters instead.
One of Mindcode goals is to facilitate making small changes to the compiled code, allowing users to change crucial parameters without having to recompile entire program. To this end, it is possible to declare program parameters, a special type of variable, using the param keyword:
param UNIT_TYPE = @flare;
param MAX_UNITS = 10;
param MEMORY = cell1;
param USER_NAME = "Pete";
This code, when compiled, produces the following instructions:
set UNIT_TYPE @flare
set MAX_UNITS 10
set MEMORY cell1
set USER_NAME "Pete"
Names of the mlog variables representing the program parameters are always the same as the names used in the source code. Values assigned through these instructions can be changed in the compiled code. When modifying values assigned to program parameters in the compiled code, the program behaves as if these values were specified in the source code itself. This is not guaranteed when changing values assigned to any other variables in the compiled mlog code.
The following values may be used when declaring program parameters:
- String or numeric literals, such as
5or"some text". - Names of linked blocks, such as
message1orswitch5. - Mindustry logic values and constant (or effectively constant) variables, such as
@flare,@coalor@mapw.
Other values, including compile-time constant expressions (e.g. 5 * 3) and built-in variables known not to be constant (e.g. @links) are not allowed.
In Mindcode, program parameters are global (can be accessed from the main program body and all functions) even when their names contain lower case letters, and once declared, are read-only. It is not allowed to assign a new value to them:
param parameter = 10; // lower-case names are ok
parameter = 20; // error, cannot assign another value to parameter.
This means there's always exactly one set instruction assigning a value to the program parameter, making the purpose of the mlog variable in the compiled code clearer.
Unlike other types of variables, program parameters are never optimized away from the code. Only when the program parameter is not used at all in the program, it may be removed by the Dead Code optimization.
Important
Correct execution of the program is only guaranteed if the value assigned to the program parameter in the compiled code is constant. When modifying the compiled code to assign a non-constant value (for example @links) to a program parameter, or when the value of the parameter may be read before being initialized, the behavior of the resulting code is generally undefined.
Mindcode supports storing variables in external memory - memory cells or memory banks linked to the processor. These variables are stored independently of the processor and can be used to share values between processors, or to keep values even when the processor is destroyed or its code altered.
On the other hand, only numeric values can be stored in external memory. It is therefore not possible to use it to store strings, units, buildings or item types there. This -- quite restrictive -- limitation is unfortunately imposed by Mindustry Logic itself.
You can use external variables using the array access syntax:
for i in 0 .. 63 do
cell2[i] = cell1[i];
end;
This code copies the entire contents of memory cell cell1 to cell2.
It is also possible to reference external memory indirectly:
def copy(source, target, size)
for i in 0 ... size do
target[i] = source[i];
end;
end;
copy(bank1, bank2, 512);
You can also have Mindcode assign identifiers to external variables. For that, you need to allocate a heap within a Memory Cell or a Memory Bank. This allocation tells the Mindcode compiler where to store the external variables. A heap is simply a region of external memory. The heap is allocated using the following Mindcode:
allocate heap in cell4[50 ... 64];
This statement allocates a heap, stored in cell4, and uses memory locations 50, 51, 52, ..., 62, and 63 (note the exclusive range). If you declare more external variables than you have allocated space for, a compilation error will occur. In that case, allocate more space for the heap in your cell, or switch to a
Memory Bank and allocate more space to your heap.
Once the heap is allocated, you can use external variables. External variables are identified by the $ (dollar-sign) prefix:
allocate heap in cell4[32 ... 64];
$dx = 1; // this is an external variable assignment
$dy = 1;
$ne_x = 90;
$ne_y = 90;
$target_y = $sw_x = 50;
$target_x = $sw_y = 50;
The above will compile to:
cell4[32] = 1
cell4[33] = 1
cell4[34] = 90
cell4[35] = 90
cell4[36] = cell4[37] = 50
cell4[38] = cell4[39] = 50
Note
External variables are allocated on a first-come, first-served basis.
If you had the following code:
allocate heap in cell2[61 .. 63];
$flag = rand(10000);
$targetx = 80;
$targety = 80;
and changed it to:
allocate heap in cell2[61 .. 63];
$targetx = 80;
$targety = 80;
$flag = rand(10000);
then all addresses in the heap would be reallocated. $targetx would be stored in memory cell 61, rather than $flag.
To fix this issue, you can either reset your heap to all zeroes on startup, or destroy and re-create your memory
cell/memory bank.
When using recursive functions, some of their local variables and parameters may have to be stored on a stack. As Mindustry Logic doesn't provide a built-in stack, external memory is used instead. This places the same limitations on local variables and parameters of recursive functions as on arrays and external variables (that is, only numeric values are supported).
Stack needs to be allocated similarly to heap:
allocate stack in bank1[256...512];
When a function is not recursive, it won't store anything on a stack, even when it is called from or it itself calls
a recursive function. If your code contains a recursive function, it won't compile unless the stack is allocated.
Therefore, if your code compiles without the allocate stack statement, you don't need to worry about your
functions not supporting non-numeric variables or parameters.
When you build your Mindcode scripts, the actual Memory Cell and Memory Bank that you use may be different from the ones you use when playing the game. To that end, you also have the option of referencing your heap and stack through the use of a program parameter, like this:
param HEAPPTR = cell3;
allocate heap in HEAPPTR;
$dx = 0;
This will translate to:
set HEAPPTR cell3
write 0 HEAPPTR 0
Since the very first instruction of the compiled code will be the program parameter assignment, you can easily change the actual cell or bank your will use, without having to do a global search & replace within the compiled code. This introduces more avenues for code sharing.
It is possible to allocate stack and heap in the same memory block, and/or in one statement:
param MEMORY = bank1;
allocate stack in MEMORY[0 ... 480], heap in MEMORY[480 ... 512];
Mindustry Logic processors have several built-in variables. Their names start with the @ sign. The most common ones are:
@counter: address of the next instruction to be executed@this,@thisx,@thisy: processor executing current code and its coordinates@mapw,@maph: dimensions of the map@time,@tick,@second,@minute: current game time expressed in various units@links: number of blocks linked to the processor@ipt: instructions per tick executed by this processor@unit: currently bound unit@unitCount,@itemCount,@liquidCount,@blockCount: counts of elements of given type, can be used with thelookupfunction.
Mindcode allows you to read these variables, but it is not possible to assign a value to them.
Some of them are constant during the lifetime of the processor, but others do - or at least may - change (@time,
@counter or @links).
@unit is a very special variable - it always contains the unit currently controlled by the processor. The only way
to assign a new unit to this variable is to use the ubind() function. All unit control commands are sent to this
unit. See also Using units.
Tip
The value of time variables (@tick, @time and so on) can actually decrease when loading a game from a save file. Take it into account especially when programming loops that should terminate at some predetermined time.
Built-in constants, such as @copper, @vela or @switch, represent items, liquids, block types, unit types, object properties and so on. They are used as-is in the Mindcode, including the @ prefix.
When a block/building (e.g. a factory, a turret or a memory cell) is linked to a processor, an object representing the linked blocks is created. This object is named using the short name of the linked block and an integer index, e.g. cell1, switch3 or smelter16. These objects allow the code to directly control or query linked blocks.
Important
If a variable with the same name as a newly linked block exists in a processor when the block is linked, it is removed from the processor. Assignments to a variable named after a linked block are silently ignored by the processor.
When compiling the code, the compiler doesn't know which blocks might be linked to the processor in Mindustry World. To avoid generating code that might stop working when blocks are linked to the processor, all possible names of linked blocks are specially handled:
- it is not possible to assign values to variables with these names,
- these variables are implicitly global.
The second point means that in the following code
def foo()
print("In function foo");
printflush(message1);
end;
the message1 variable represents a message block linked to the processor, even when used inside a function.
The list of possible block names is quite extensive.
Show full list of Mindustry block names.
acropolisafflictarcassemblerbankbastionbatteryborebreachbridgecanvascellcentrifugechambercitadelcompressorconcentratorcondenserconduitconstructorcontainerconveyorcruciblecrushercultivatorcyclonedeconstructordiffusediodedisassemblerdispersedisplaydistributordomedoordrilldriverductduoelectrolyzerextractorfabricatorfactoryforeshadowfoundationfurnacefusegategeneratorgigantichailheaterhugeilluminatorincineratorjunctionkilnlancerlinkloaderlustremalignmeltdownmeltermendermessageminemixermodulenodenucleuspadpanelparallaxpointpressprocessorprojectorpulverizerpumpradarreactorreconstructorredirectorrefabricatorrippleroutersalvoscathescatterscorchsegmentseparatorshardsmeltersmitesortersourcespectresublimateswarmerswitchsynthesizertankthrustertitantowertsunamiturretunloadervaultvoidwallwaveweaver
Any variable name consisting of one of these prefixes and a positive integer is a reserved for linked blocks.
- These are block names:
point3,arc7,tank999999. - These aren't:
switch(no numeric index at all),cell05(leading zero),Router15(upper-case letter) orwave_1(the index doesn't immediately follow the block name).
Mindcode supports declaring and using constants throughout your code. Constants are declared using the const keyword:
const DEBUG = true;
const HIGH_SPEED = 50;
const LOW_SPEED = HIGH_SPEED / 2;
const RATIO = sqrt(2);
const message = DEBUG ? "Debug" : "Release";
const FORMAT = $"Position: $, $";
Constants are global, even if their names contain lower-case characters. The value assigned to them must be either a
numeric, boolean or text literal, or an expression whose value can be computed at compile time. Compile-time
evaluation uses the same rules as Mindustry Logic, i.e. const ERROR = 1 / 0 is a valid constant declaration which
creates a constant ERROR with a value of null.
If a numeric value is assigned to a constant, and it isn't possible to encode the value into an mlog literal, a compilation error occurs.
A name used for a constant cannot be used for a main, global or local variable.
Unlike program parameters, constants aren't kept in processor variables, and their values therefore cannot be changed in compiled code. It also means that in the following code
const DEBUG = false;
...
if DEBUG then
println("State: ", state);
println("Item count: ", @unit.totalItems);
end;
the entire if DEBUG ... end statement will be skipped and not included in the compiled code.
Mindustry has a set of built-in icons that are represented by specific Unicode characters and are properly rendered in all the user interface elements. While it would be possible to enter a corresponding Unicode character into a String literal directly, it would be probably a bit cumbersome. To provide access to these icons, Mindcode comes with a predefined set of constants that correspond to individual icons. The constants map the symbolic icon names onto a String literal containing their corresponding Unicode character.
Printing an icon is as easy as this:
print(ITEM_LEAD, " ", vault1.lead, "\n");
print(ITEM_COAL, " ", vault1.coal, "\n");
print(ITEM_BLAST_COMPOUND, " ", vault1.blast-compound);
printflush(message1);
As has already been mentioned, names of the icons are constants and cannot therefore be used for user-defined constants or variables.
The list of all existing icons is quite huge:
Show full list of Mindustry block icons.
BLOCK_ADDITIVE_RECONSTRUCTORBLOCK_AFFLICTBLOCK_AIR_FACTORYBLOCK_ALPHA_MECH_PADBLOCK_ARCBLOCK_ARKYCITE_FLOORBLOCK_ARKYIC_BOULDERBLOCK_ARKYIC_STONEBLOCK_ARKYIC_VENTBLOCK_ARKYIC_WALLBLOCK_ARMORED_CONVEYORBLOCK_ARMORED_DUCTBLOCK_ATMOSPHERIC_CONCENTRATORBLOCK_BALLISTIC_SILOBLOCK_BARRIER_PROJECTORBLOCK_BASALTBLOCK_BASALT_BOULDERBLOCK_BASIC_ASSEMBLER_MODULEBLOCK_BASIC_RECONSTRUCTORBLOCK_BATTERYBLOCK_BATTERY_LARGEBLOCK_BEAM_DRILLBLOCK_BEAM_LINKBLOCK_BEAM_NODEBLOCK_BEAM_TOWERBLOCK_BERYLLIC_BOULDERBLOCK_BERYLLIC_STONEBLOCK_BERYLLIC_STONE_WALLBLOCK_BERYLLIUM_WALLBLOCK_BERYLLIUM_WALL_LARGEBLOCK_BLAST_DOORBLOCK_BLAST_DRILLBLOCK_BLAST_MIXERBLOCK_BLOCK_FORGEBLOCK_BLOCK_LAUNCHERBLOCK_BLOCK_LOADERBLOCK_BLOCK_UNLOADERBLOCK_BLUEMATBLOCK_BOULDERBLOCK_BREACHBLOCK_BRIDGE_CONDUITBLOCK_BRIDGE_CONVEYORBLOCK_BUILD_TOWERBLOCK_CANVASBLOCK_CARBIDE_CRUCIBLEBLOCK_CARBIDE_WALLBLOCK_CARBIDE_WALL_LARGEBLOCK_CARBON_BOULDERBLOCK_CARBON_STONEBLOCK_CARBON_VENTBLOCK_CARBON_WALLBLOCK_CELL_SYNTHESIS_CHAMBERBLOCK_CHARBLOCK_CHEMICAL_COMBUSTION_CHAMBERBLOCK_CLIFFBLOCK_CLIFF_CRUSHERBLOCK_CLIFFSBLOCK_COAL_CENTRIFUGEBLOCK_COMBUSTION_GENERATORBLOCK_COMMAND_CENTERBLOCK_CONDUITBLOCK_CONSTRUCTORBLOCK_CONTAINERBLOCK_CONVEYORBLOCK_COPPER_WALLBLOCK_COPPER_WALL_LARGEBLOCK_CORE_ACROPOLISBLOCK_CORE_BASTIONBLOCK_CORE_CITADELBLOCK_CORE_FOUNDATIONBLOCK_CORE_NUCLEUSBLOCK_CORE_SHARDBLOCK_CORE_SILOBLOCK_CORE_ZONEBLOCK_CRATER_STONEBLOCK_CRATERSBLOCK_CRAWLER_FACTORYBLOCK_CRYOFLUID_MIXERBLOCK_CRYSTAL_BLOCKSBLOCK_CRYSTAL_CLUSTERBLOCK_CRYSTAL_FLOORBLOCK_CRYSTAL_ORBSBLOCK_CRYSTALLINE_BOULDERBLOCK_CRYSTALLINE_STONEBLOCK_CRYSTALLINE_STONE_WALLBLOCK_CRYSTALLINE_VENTBLOCK_CULTIVATORBLOCK_CYANOGEN_SYNTHESIZERBLOCK_CYCLONEBLOCK_DACITEBLOCK_DACITE_BOULDERBLOCK_DACITE_WALLBLOCK_DAGGER_FACTORYBLOCK_DARK_METALBLOCK_DARK_PANEL_1BLOCK_DARK_PANEL_2BLOCK_DARK_PANEL_3BLOCK_DARK_PANEL_4BLOCK_DARK_PANEL_5BLOCK_DARK_PANEL_6BLOCK_DARKSANDBLOCK_DARKSAND_TAINTED_WATERBLOCK_DARKSAND_WATERBLOCK_DART_MECH_PADBLOCK_DART_SHIP_PADBLOCK_DATA_PROCESSORBLOCK_DECONSTRUCTORBLOCK_DEEP_TAINTED_WATERBLOCK_DEEP_WATERBLOCK_DEEPWATERBLOCK_DELTA_MECH_PADBLOCK_DENSE_RED_STONEBLOCK_DIFFERENTIAL_GENERATORBLOCK_DIFFUSEBLOCK_DIODEBLOCK_DIRTBLOCK_DIRT_WALLBLOCK_DISASSEMBLERBLOCK_DISPERSEBLOCK_DISTRIBUTORBLOCK_DOORBLOCK_DOOR_LARGEBLOCK_DRAUG_FACTORYBLOCK_DUCTBLOCK_DUCT_BRIDGEBLOCK_DUCT_ROUTERBLOCK_DUCT_UNLOADERBLOCK_DUNE_WALLBLOCK_DUOBLOCK_ELECTRIC_HEATERBLOCK_ELECTROLYZERBLOCK_EMPTYBLOCK_ERUPTION_DRILLBLOCK_EXPONENTIAL_RECONSTRUCTORBLOCK_FABRICATORBLOCK_FERRIC_BOULDERBLOCK_FERRIC_CRATERSBLOCK_FERRIC_STONEBLOCK_FERRIC_STONE_WALLBLOCK_FLUX_REACTORBLOCK_FORCE_PROJECTORBLOCK_FORESHADOWBLOCK_FORTRESS_FACTORYBLOCK_FRACTUREBLOCK_FUSEBLOCK_GHOUL_FACTORYBLOCK_GLAIVE_SHIP_PADBLOCK_GRAPHITE_PRESSBLOCK_GRAPHITIC_WALLBLOCK_GRASSBLOCK_GROUND_FACTORYBLOCK_HAILBLOCK_HEAT_REACTORBLOCK_HEAT_REDIRECTORBLOCK_HEAT_ROUTERBLOCK_HEAT_SOURCEBLOCK_HOTROCKBLOCK_HYPER_PROCESSORBLOCK_ICEBLOCK_ICE_SNOWBLOCK_ICE_WALLBLOCK_IGNAROCKBLOCK_ILLUMINATORBLOCK_IMPACT_DRILLBLOCK_IMPACT_REACTORBLOCK_IMPULSE_PUMPBLOCK_INCINERATORBLOCK_INTERPLANETARY_ACCELERATORBLOCK_INVERTED_SORTERBLOCK_ITEM_SOURCEBLOCK_ITEM_VOIDBLOCK_JAVELIN_SHIP_PADBLOCK_JUNCTIONBLOCK_KILNBLOCK_LANCERBLOCK_LARGE_CONSTRUCTORBLOCK_LARGE_LOGIC_DISPLAYBLOCK_LARGE_OVERDRIVE_PROJECTORBLOCK_LARGE_PAYLOAD_MASS_DRIVERBLOCK_LARGE_PLASMA_BOREBLOCK_LARGE_SHIELD_PROJECTORBLOCK_LASER_DRILLBLOCK_LAUNCH_PADBLOCK_LAUNCH_PAD_LARGEBLOCK_LEGACY_COMMAND_CENTERBLOCK_LEGACY_MECH_PADBLOCK_LEGACY_UNIT_FACTORYBLOCK_LEGACY_UNIT_FACTORY_AIRBLOCK_LEGACY_UNIT_FACTORY_GROUNDBLOCK_LIQUID_CONTAINERBLOCK_LIQUID_JUNCTIONBLOCK_LIQUID_ROUTERBLOCK_LIQUID_SOURCEBLOCK_LIQUID_TANKBLOCK_LIQUID_VOIDBLOCK_LOGIC_DISPLAYBLOCK_LOGIC_PROCESSORBLOCK_LUSTREBLOCK_MAGMAROCKBLOCK_MALIGNBLOCK_MASS_CONVEYORBLOCK_MASS_DRIVERBLOCK_MECH_ASSEMBLERBLOCK_MECH_FABRICATORBLOCK_MECH_RECONSTRUCTORBLOCK_MECH_REFABRICATORBLOCK_MECHANICAL_DRILLBLOCK_MECHANICAL_PUMPBLOCK_MELTDOWNBLOCK_MELTERBLOCK_MEMORY_BANKBLOCK_MEMORY_CELLBLOCK_MEND_PROJECTORBLOCK_MENDERBLOCK_MESSAGEBLOCK_METAL_FLOORBLOCK_METAL_FLOOR_2BLOCK_METAL_FLOOR_3BLOCK_METAL_FLOOR_4BLOCK_METAL_FLOOR_5BLOCK_METAL_FLOOR_DAMAGEDBLOCK_MICRO_PROCESSORBLOCK_MOLTEN_SLAGBLOCK_MOSSBLOCK_MUDBLOCK_MULTI_PRESSBLOCK_MULTIPLICATIVE_RECONSTRUCTORBLOCK_NAVAL_FACTORYBLOCK_NEOPLASIA_REACTORBLOCK_NUCLEAR_WARHEADBLOCK_OIL_EXTRACTORBLOCK_OMEGA_MECH_PADBLOCK_ORE_BERYLLIUMBLOCK_ORE_COALBLOCK_ORE_COPPERBLOCK_ORE_CRYSTAL_THORIUMBLOCK_ORE_LEADBLOCK_ORE_SCRAPBLOCK_ORE_THORIUMBLOCK_ORE_TITANIUMBLOCK_ORE_TUNGSTENBLOCK_ORE_WALL_BERYLLIUMBLOCK_ORE_WALL_THORIUMBLOCK_ORE_WALL_TUNGSTENBLOCK_OVERDRIVE_DOMEBLOCK_OVERDRIVE_PROJECTORBLOCK_OVERFLOW_DUCTBLOCK_OVERFLOW_GATEBLOCK_OXIDATION_CHAMBERBLOCK_OXIDIZERBLOCK_PARALLAXBLOCK_PAYLOAD_CONVEYORBLOCK_PAYLOAD_INCINERATORBLOCK_PAYLOAD_LOADERBLOCK_PAYLOAD_MASS_DRIVERBLOCK_PAYLOAD_ROUTERBLOCK_PAYLOAD_SOURCEBLOCK_PAYLOAD_UNLOADERBLOCK_PAYLOAD_VOIDBLOCK_PEBBLESBLOCK_PHANTOM_FACTORYBLOCK_PHASE_CONDUITBLOCK_PHASE_CONVEYORBLOCK_PHASE_HEATERBLOCK_PHASE_SYNTHESIZERBLOCK_PHASE_WALLBLOCK_PHASE_WALL_LARGEBLOCK_PHASE_WEAVERBLOCK_PINEBLOCK_PLASMA_BOREBLOCK_PLASTANIUM_COMPRESSORBLOCK_PLASTANIUM_CONVEYORBLOCK_PLASTANIUM_WALLBLOCK_PLASTANIUM_WALL_LARGEBLOCK_PLATED_CONDUITBLOCK_PNEUMATIC_DRILLBLOCK_POOLED_CRYOFLUIDBLOCK_POWER_NODEBLOCK_POWER_NODE_LARGEBLOCK_POWER_SOURCEBLOCK_POWER_VOIDBLOCK_PRESSURE_TURBINEBLOCK_PRIME_REFABRICATORBLOCK_PULSE_CONDUITBLOCK_PULVERIZERBLOCK_PUR_BUSHBLOCK_PYRATITE_MIXERBLOCK_PYROLYSIS_GENERATORBLOCK_RADARBLOCK_RAVAGEBLOCK_RED_DIAMOND_WALLBLOCK_RED_ICEBLOCK_RED_ICE_BOULDERBLOCK_RED_ICE_WALLBLOCK_RED_STONEBLOCK_RED_STONE_BOULDERBLOCK_RED_STONE_VENTBLOCK_RED_STONE_WALLBLOCK_REDMATBLOCK_REDWEEDBLOCK_REFABRICATORBLOCK_REGEN_PROJECTORBLOCK_REGOLITHBLOCK_REGOLITH_WALLBLOCK_REINFORCED_BRIDGE_CONDUITBLOCK_REINFORCED_CONDUITBLOCK_REINFORCED_CONTAINERBLOCK_REINFORCED_LIQUID_CONTAINERBLOCK_REINFORCED_LIQUID_JUNCTIONBLOCK_REINFORCED_LIQUID_ROUTERBLOCK_REINFORCED_LIQUID_TANKBLOCK_REINFORCED_MESSAGEBLOCK_REINFORCED_PAYLOAD_CONVEYORBLOCK_REINFORCED_PAYLOAD_ROUTERBLOCK_REINFORCED_PUMPBLOCK_REINFORCED_SURGE_WALLBLOCK_REINFORCED_SURGE_WALL_LARGEBLOCK_REINFORCED_VAULTBLOCK_REPAIR_POINTBLOCK_REPAIR_TURRETBLOCK_RESUPPLY_POINTBLOCK_REVENANT_FACTORYBLOCK_RHYOLITEBLOCK_RHYOLITE_BOULDERBLOCK_RHYOLITE_CRATERBLOCK_RHYOLITE_VENTBLOCK_RHYOLITE_WALLBLOCK_RIPPLEBLOCK_ROCKBLOCK_ROTARY_PUMPBLOCK_ROUGH_RHYOLITEBLOCK_ROUTERBLOCK_RTG_GENERATORBLOCK_SALTBLOCK_SALT_WALLBLOCK_SALVOBLOCK_SANDBLOCK_SAND_BOULDERBLOCK_SAND_FLOORBLOCK_SAND_WALLBLOCK_SAND_WATERBLOCK_SCATHEBLOCK_SCATTERBLOCK_SCORCHBLOCK_SCRAP_WALLBLOCK_SCRAP_WALL_GIGANTICBLOCK_SCRAP_WALL_HUGEBLOCK_SCRAP_WALL_LARGEBLOCK_SEGMENTBLOCK_SEPARATORBLOCK_SHALEBLOCK_SHALE_BOULDERBLOCK_SHALE_WALLBLOCK_SHALLOW_WATERBLOCK_SHIELD_PROJECTORBLOCK_SHIELDED_WALLBLOCK_SHIP_ASSEMBLERBLOCK_SHIP_FABRICATORBLOCK_SHIP_RECONSTRUCTORBLOCK_SHIP_REFABRICATORBLOCK_SHOCK_MINEBLOCK_SHOCKWAVE_TOWERBLOCK_SHRUBSBLOCK_SILICON_ARC_FURNACEBLOCK_SILICON_CRUCIBLEBLOCK_SILICON_SMELTERBLOCK_SLAG_CENTRIFUGEBLOCK_SLAG_HEATERBLOCK_SLAG_INCINERATORBLOCK_SMALL_DECONSTRUCTORBLOCK_SMITEBLOCK_SNOWBLOCK_SNOW_BOULDERBLOCK_SNOW_PINEBLOCK_SNOW_WALLBLOCK_SNOWROCKBLOCK_SOLAR_PANELBLOCK_SOLAR_PANEL_LARGEBLOCK_SORTERBLOCK_SPACEBLOCK_SPAWNBLOCK_SPECTREBLOCK_SPIRIT_FACTORYBLOCK_SPORE_CLUSTERBLOCK_SPORE_MOSSBLOCK_SPORE_PINEBLOCK_SPORE_PRESSBLOCK_SPORE_WALLBLOCK_STEAM_GENERATORBLOCK_STEAM_VENTBLOCK_STONEBLOCK_STONE_WALLBLOCK_SUBLIMATEBLOCK_SURGE_CONVEYORBLOCK_SURGE_CRUCIBLEBLOCK_SURGE_DUCTBLOCK_SURGE_ROUTERBLOCK_SURGE_SMELTERBLOCK_SURGE_TOWERBLOCK_SURGE_WALLBLOCK_SURGE_WALL_LARGEBLOCK_SWARMERBLOCK_SWITCHBLOCK_TAINTED_WATERBLOCK_TANK_ASSEMBLERBLOCK_TANK_FABRICATORBLOCK_TANK_RECONSTRUCTORBLOCK_TANK_REFABRICATORBLOCK_TARBLOCK_TAU_MECH_PADBLOCK_TENDRILSBLOCK_TETRATIVE_RECONSTRUCTORBLOCK_THERMAL_GENERATORBLOCK_THORIUM_REACTORBLOCK_THORIUM_WALLBLOCK_THORIUM_WALL_LARGEBLOCK_THRUSTERBLOCK_TITANBLOCK_TITAN_FACTORYBLOCK_TITANIUM_CONVEYORBLOCK_TITANIUM_WALLBLOCK_TITANIUM_WALL_LARGEBLOCK_TRIDENT_SHIP_PADBLOCK_TSUNAMIBLOCK_TUNGSTEN_WALLBLOCK_TUNGSTEN_WALL_LARGEBLOCK_TURBINE_CONDENSERBLOCK_UNDERFLOW_DUCTBLOCK_UNDERFLOW_GATEBLOCK_UNIT_CARGO_LOADERBLOCK_UNIT_CARGO_UNLOAD_POINTBLOCK_UNIT_REPAIR_TOWERBLOCK_UNLOADERBLOCK_VAULTBLOCK_VENT_CONDENSERBLOCK_VIBRANT_CRYSTAL_CLUSTERBLOCK_WALL_ORE_BERYLLIUMBLOCK_WALL_ORE_TUNGSTENBLOCK_WARHEAD_ASSEMBLERBLOCK_WATER_EXTRACTORBLOCK_WAVEBLOCK_WHITE_TREEBLOCK_WHITE_TREE_DEADBLOCK_WORLD_CELLBLOCK_WORLD_MESSAGEBLOCK_WORLD_PROCESSORBLOCK_WRAITH_FACTORYBLOCK_YELLOW_STONEBLOCK_YELLOW_STONE_BOULDERBLOCK_YELLOW_STONE_PLATESBLOCK_YELLOW_STONE_VENTBLOCK_YELLOW_STONE_WALLBLOCK_YELLOWCORAL
Show full list of Mindustry item/liquid icons.
ITEM_BERYLLIUMITEM_BLAST_COMPOUNDITEM_CARBIDEITEM_COALITEM_COPPERITEM_DORMANT_CYSTITEM_FISSILE_MATTERITEM_GRAPHITEITEM_LEADITEM_METAGLASSITEM_OXIDEITEM_PHASE_FABRICITEM_PLASTANIUMITEM_PYRATITEITEM_SANDITEM_SCRAPITEM_SILICONITEM_SPORE_PODITEM_SURGE_ALLOYITEM_THORIUMITEM_TITANIUMITEM_TUNGSTENLIQUID_ARKYCITELIQUID_CRYOFLUIDLIQUID_CYANOGENLIQUID_GALLIUMLIQUID_HYDROGENLIQUID_NEOPLASMLIQUID_NITROGENLIQUID_OILLIQUID_OXYGENLIQUID_OZONELIQUID_SLAGLIQUID_WATER
Show full list of Mindustry status and team icons.
STATUS_BLASTEDSTATUS_BOSSSTATUS_BURNINGSTATUS_CORRODEDSTATUS_DISARMEDSTATUS_ELECTRIFIEDSTATUS_FREEZINGSTATUS_INVINCIBLESTATUS_MELTINGSTATUS_MUDDYSTATUS_NONESTATUS_OVERCLOCKSTATUS_OVERDRIVESTATUS_SAPPEDSTATUS_SHIELDEDSTATUS_SHOCKEDSTATUS_SLOWSTATUS_SPORE_SLOWEDSTATUS_TARREDSTATUS_UNMOVINGSTATUS_WETTEAM_CRUXTEAM_DERELICTTEAM_MALISTEAM_SHARDED
Show full list of Mindustry unit icons.
UNIT_AEGIRESUNIT_ALPHAUNIT_ANTHICUSUNIT_ANTHICUS_MISSILEUNIT_ANTUMBRAUNIT_ARKYIDUNIT_ASSEMBLY_DRONEUNIT_ATRAXUNIT_AVERTUNIT_BETAUNIT_BLOCKUNIT_BRYDEUNIT_CATACLYSTUNIT_CLEROIUNIT_COLLARISUNIT_CONQUERUNIT_CORVUSUNIT_CRAWLERUNIT_CYERCEUNIT_DAGGERUNIT_DISRUPTUNIT_DISRUPT_MISSILEUNIT_ECLIPSEUNIT_EFFECT_DRONEUNIT_ELUDEUNIT_EMANATEUNIT_EVOKEUNIT_FLAREUNIT_FORTRESSUNIT_GAMMAUNIT_HORIZONUNIT_INCITEUNIT_LATUMUNIT_LOCUSUNIT_MACEUNIT_MANIFOLDUNIT_MEGAUNIT_MERUIUNIT_MINKEUNIT_MONOUNIT_NAVANAXUNIT_NOVAUNIT_OBVIATEUNIT_OCTUNIT_OMURAUNIT_OSCUNIT_OXYNOEUNIT_POLYUNIT_PRECEPTUNIT_PULSARUNIT_QUADUNIT_QUASARUNIT_QUELLUNIT_QUELL_MISSILEUNIT_REIGNUNIT_RENALEUNIT_RETUSAUNIT_RISSEUNIT_RISSOUNIT_SCATHE_MISSILEUNIT_SCEPTERUNIT_SEIUNIT_SPIROCTUNIT_STELLUNIT_TECTAUNIT_TOXOPIDUNIT_TURRET_UNIT_BUILD_TOWERUNIT_VANQUISHUNIT_VELAUNIT_VESTIGEUNIT_ZENITH
Show full list of Mindustry unclassified icons.
ALPHAAAACRATER
« Previous: Mindcode basics | Up: Contents | Next: Expressions »