Foreword

This documentation was written mostly by me, so there may be inaccuracies or omissions. As English is not my first language, I apologize for any spelling or grammar errors. If you have any corrections, additions, or suggestions, please feel free to contact me to discuss them. Or if you just want to ask questions, I’ll be happy to help you can DM me on
Discord (Yruei)
Reddit (u/Far_Kale558 asdfasdf)
or make an issue Here


this is the new website, images are rendered at 100% resolution, meaning no matter how small you screen is if you zoom in enough it will show its original resolution.

Introduction

What is Mindustry logic?

Mindustry Logic (mlog) is a scripting language added in v6 for the purpose of introducing more advanced automation and strategy into the game It is heavily inspired by Assembly languages, therefore the language is a low level language making it harder to understand (low level being low to machine language (Assembly, C, etc) and far from human language, high level language example are (python, javaScript, C#, etc) if you have previous programming experience it's very easy to learn but people who are entirely new to programming might find this a little confusing.

Fun fact, it is turing complete (meaning you can literally do anything a real computer can, although the practicality is questionable), it is often used for more advanced automation (telling units what to do, disabling/enabling blocks, and more), For more advanced people, they like to mess around just for fun making stuff that are not actually useful to campaign like games, emulators, renderings, etc.

mlog is not necessary for the completion of campaign , it is very optional, often the time you spent coding will be more than if you just do it manually..

Glossary

Data types

Basic concept

Processor’s UI

when opening a processor by clicking the pencil icon:

you will be prompted to this screen:

the “Add” button () opens a menu to add an instruction:

the “Vars” button () opens a menu showing all of your variables

the “edit” button ()opens a menu to export/import codes

when clicking “Copy to Clipboard” it will copy the code of the processor to your clipboard, unlike a schematic, mlog code are plain readable text, click here for more info
this mlog code can be pasted into a processor again using the "import from clipboard"

How Processor run its code

They Always run Instruction from top to bottom 1 at a time You can only jump and wait, you cannot make it run from bottom to top for example. Here is a visualization:

with jumps:

When the processor reach the end of its instruction it will go back to 0, repeating the loop indefinitely

Links

You can link a building to the processor by clicking the processor (you can see a circle, this is the processor range) and clicking the building

`display1` is now a variable that can be used in the processor, it stores a building reference, is also sometimes called a “building variable”,
building variable cannot be overwritten by any means,
in other words, you cannot use this variable to put in an output of an instruction
however you can copy the its contents to another variable, Like set myBuilding = display1
the variable `myBuilding` is now the same as `display1`, meaning you can use it the same way

Variables

Variables are the fundamental of programming, to put it simply, they are just named “containers” to store data to, for example the Set instruction sets a variable:

This will make `x` a variable, this variable can be used for all sort of different things, for example, the Operation instruction

Because `x` is 10 this operation means 10 + 5, and the result of it is written to the `result` variable, meaning `result` is now 15 Of course it doesn’t have to be `result`, you can write anything for it, different people write their variable differently, some chooses to write arbitrary words/letters like “peach” and others simply write “x+5”, whatever you choose is up to you, just keep in mind you have to remember them.

a processor doesn't have a limit on how many variables it can have, however a processor has a 1000 instruction limit

Incrementing Variable

Increment is the act or process of increasing

Since processor loops, this will increase `x` by 1 every loop, as time goes on x will get bigger and bigger. This is what’s called incrementing a variable

Buffers

Internally there is a Text buffer and a Draw buffer in each processor, when you use print or draw, when the processor runs it, it will store it in the buffer. Example: if you print “frog” the word “frog” will be stored in the text buffer, then to get that word to a message block you have to use Print Flush which transfer the items in the text buffer to the message block

It's the same case with draw.

The draw buffer has 256 item limit, meaning you can only draw 256 times before needing to flush, otherwise everything after 256 just gets thrown out, displays also have a buffer limit, 1024 / tick to be exact, this means if you flush 1025 items to 1 display in 1 tick 1 item will be lost.

The text buffer has a 400 character limit, for example “frog” is 4 characters. Even though the message block has a 220 characters limit you can still print 400 characters to it.

Blocks

Message

Is used with Print and Print Flush, can also be manually written by clicking it and clicking the pencil icon.
has 220 characters limit (including spaces)
will only show its text when hovered

Switch

Has 2 states, enabled and disabled / 1 and 0, state can be read using Sensor instruction, and can also be controlled with Control instruction.

Logic displays and Large

Is used with Draw and Draw Flush,
Normal display has a 88 * 88 resolution
Large display has a 176 * 176 resolution
the border (Bezel) is 8 pixels

Memory cell and Memory Bank

A cell can store up to 64 values, but only numbers, while Bank can store up to 512 values
How it works:

Let’s use a cell as an example, imagine it is like a numbered storage boxes



the number below are called addresses, since a cell can store up to 64 values that means there are 64 addresses in a cell, from #0 to #63 you can then store a number in this line of boxes by an address, for example if you want to store a number to box number #3 you would write:



this will store the number 1838 to box number #3, you then can read it again using read



this will read whatever inside box number #3 (1838) and put it in a variable called `result`, therefore `result` is now 1838

The largest integer that can be represented accurately in a single address (double-precision floating-point format) is 2^53, which equals 9007199254740992. from -2^53 , which is −9007199254740992. Beyond these limits, floating-point representation may lead to inaccuracies due to the way numbers are rounded.

Instructions

Read

Read a value from a cell

`result` is your variable name
`cell1` is where to get the value from, a building reference, “bank{number}” for Banks
`0` is the cell’s address. like said above, cells can store up to 64 values, this means there are only 64 addresses, starting at 0, meaning 0 - 63
Example: there is a value at 0 in `cell1` that is `10`, then `result` variable will be 10

Write

Write a value to a cell

Essentially the same with read but it writes instead
Example: the `result` variable is 10, then it will write `10` to `cell1` at 0
Can also be directly written using a number instead of a variable.

Draw

Adds a command to the draw buffer

1. Clear

Sets the entire screen to a specific color

RGB stands for Red,Green,Blue
Value can be from 0 (dimmest) to 255 (brightest)
Example: 255, 255, 255 is White

2. Color

Sets the color of the next upcoming draw isntruction

RGBA stands for Red,Green,Blue,Alpha
To put it simply Alpha is Opacity, it is how opaque the next draw instruction will be
0 is 0% and 255 is 100% opaque
Value can be from 0 (dimmest) to 255 (brightest)

col

Same as color, but use hex color code instead of RGB color code Usually used with the Pack Color instruction

3. Stroke

Sets the line width for any upcoming draw operations

4. Line

Draws a line from one coordinates to another coordinates

x,y is the first set of coordinates
x2,y2 is the second sets of coordinates

5. Rect

Draw a rectangle at the specified coordinates with the bottom left of the rectangle as its origin

x,y is the rectangle coordinates
Width and height are the rectangle width and height

6. Line Rect

Same as rect, but only draws the outline of the rectangle

7. Poly

Draw a polygon with its center as its origin

x,y is the polygon coordinates
sides is the number of sides the polygon will have
radius is the radius of the polygon
rotation will rotate the polygon, in degrees

8. Line Poly

Same as poly, but only draws the outline of the polygon

9. Triangle

Draws a triangle with 3 different sets coordinates as its vertices

x,y is the first sets of coordinates
x2,y2 is the second sets of coordinates
x3,y3 is the second sets of coordinates

10. Image

Draws an image of something from the game with content name, such as @dagger or @copper with its center as its origin,
if it draws a picture of (oh no) that means whatever you're trying to draw either doesn't exist or not supported, the only work around is drawing it manually, though the Bleeding Edge version supports more content

x,y is the of coordinates
image is what image it will draw, you put object name here, like @dagger
size is the size of the image
rotation will rotate the image, in degrees
cannot draw modded items!

Draw Flush

Flush the queued draw instruction(s) from the draw buffer to the specified displays with its building reference

Print

Prints the specified value to the text buffer, can print both text and variables
however you cannot print text and variable in 1 instruction, you have to use multiple instruction

1. \n

Writing \n will write the next text to a new line, example:


2. Printing colors “ [ ] "

You can change printed colors with [ ], example

You can either put color names or hexadecimal color code
Example of HEX color code is [#FF0000] for red, you can simply search “hex color picker” on google to choose your own color

Print Flush

Flush the queued print instruction(s) from the text buffer to the specified message block with its building reference, will erases previous message on the message block

Get link

Get link gets the link of the processor linked building
example : you have 2 buildings linked to the processor, `duo1` and `duo2`
getlink `result` #0 will get you `duo1` and
getlink `result` #1 will get you `duo2`
The order is based on the order you link the buildings
The buildings reference is then `result`

Using it with numbers is pretty useless, they are usually used with incrementing variables as its index, this way you can get multiple buildings without writing every building reference (message1,2,3….)

Control

Controls a building of a building reference or a unit reference

1. Enabled

Enabled or disable a building, can be 0 or 1 or true and false

of a block reference
to (state), 1 / true enable, 0 / false disable,
when disabling a processor it pauses code execution until re-enabled again, resuming at the line number where it was disabled
here is a list of blocks behaviour when disabled

2. Shoot

Shoot at a coordinate position,

x and y is coordinate location where to aim/shoot at
shoot 0 or 1, true or false, if true tells the turret/unit to shoot, if false stop shooting

3. Shootp

Shoot at a unit/building but with velocity prediction

unit, what object to aim/shoot at, it says "unit" but you can put a building reference there too.
shoot 0 or 1, true or false, if true tells the turret/unit to shoot, if false stop shooting

4. Config

Change the configuration of buildings,
for example :
sorter config, by putting item name to the to arguments, eg @copper, @lead, @surge-alloy
unit factory config, by putting unit name to the to arguments, eg @flare, @dagger, and of course it only supports units it meant to create, if you put other unit name that it cant create it will just deselect all unit

Color

Change the color of Illuminator block Usually used with pack color

Radar

Radar a unit in range of the building’s range

‘from’ is building reference
‘target’ is a filter, target enemy means it will only radar enemy units
‘order’ is sorting order, ascending or descending, can only be 0 or 1
‘sort’ is a metric to sort results by sort distance means it will get unit by distance
Since order is 1, the unit gotten is the closest to that building
Cannot get multiple units at the same time
Order cannot be change to look for metrics in the middle e.g 0.5
Will output the unit reference to `result`

Sensor

Sensor / get / read data from an object, usually buildings or units with their reference

`results` is your named variable
“@copper” is what data to get from the specified object, can be a unit or a building. (click the pencil icon beside it for a list of sensorable data alternatively see Sensors for a list with explanation on each one)
“block1” building reference, it is what object to get the data from, can also be a unit reference
Example:

This will get the amount of copper in ‘vault1’, the number will be stored in the variable `result`, let’s say the vault has 10 coppers, therefore ‘result’ will be 10

Set

Set a variable, either with numbers or with another variable (including unit or block reference)

Operation

Perform a single operation on 2 variables, or just numbers directly, example:

Let’s say `a` is 10, therefore this operation means 10 + 5
“result” will then be 15

1. +

Addition

2. -

Subtraction

3. *

Multiplication

4. /

Division

5. //

Integer division, like division but it will round down the results

6. %

Modulo operation, like division but it returns the remainder

7. ^

Power / exponentiation

8. Sqrt

Square root

9. ==

Check if the 2 variables are equal to each other
Returns 1 or 0 / true or false

10. Not

Logical not, check if the 2 variables are not equal to each other
Returns 1 or 0 / true or false

11. And

Logical AND gate
Inputs and output are boolean

12. <

Less than, check if the first variable is less than the second variable
Returns 1 or 0 / true or false

13. >

Less than equal, check if the first variable is less than equal the second variable
Returns 1 or 0 / true or false

14. <=

Greater than, check if the first variable is greater than the second variable
Returns 1 or 0 / true or false

15. >=

Greater than equal, check if the first variable is greater than equal the second variable
Returns 1 or 0 / true or false

16. log

Logarithm, return the exponent given the base and the result

17. log 10

Logarithm in base 10

18. abs

Absolute number

19. floor

Floor , Round down the specified number

20. ceil

Ceiling , Round up the specified number

21. or

Bitwise or

22. b-and

Bitwise and

23. XOR

Bitwise XOR

24. flip

Bitwise flip

25. max

return the largest number out of the 2 number

26. min

return the smallest number out of the 2 number

27. angle

Angle of vector in degrees,usually used like: Angle = ((x1-x2) (y1-y2))

28. angle diff

Absolute distance between to angles in degrees, usually used like: angdiff = (ang1)(ang2)

29. len

Length of vector, usually used like: len = ((x1-x2) (y1-y2))

30. noise

2d simplex noise

31. rand

generate a random float in range of 0 to the specified value

32. sin

Sin, in degrees

33. cos

Cos, in degrees

34. tan

Tan, in degrees

35. asin

Asin, in degrees

36. acos

Acos, in degrees

37. atan

Atan, in degrees

Lookup

Look up an item/liquid/unit/block type by ID.
Total counts of each type can be accessed with:
@unitcount / @itemCount / @liquidCount / @blockCount, which is :
56 / 22 / 11 / 254 (as of v146), respectively, they are a constant.
For the inverse operation, sensor @id of the object
Example:

This operation is looking up item with an id of 1, which is lead, therefore `result` will then be @lead (NOT a string), a content name, which can be used for things like sensor :

`lead_count` is now a variable containing number of lead in `vault1`
Lookup are usually used with an incrementing variable
Lists of IDs can be found in the Appendix

Pack Color

Packs RGBA color into a single number, is usually used with draw col and control color
Since it's a single number it can be stored to 1 address on cells/banks, instead of 4 addresses with the usual RGBA, making reading and writing a lot easier too.
RGBA is their respective color, can also be directly written with a number, value is from 0 (dimmest) to 1 (brightest) You can unpack a Packed color by dividing it by %00000001, this will return 32-bit unsigned integer, 8 bits for each value, example : a 255,255,255,255 color when unpacked will return 4294967295, which is the maximum value of 32-bit unsigned integer, converting it to binary will return 11111111111111111111111111111111 ( 8 bit for each value ), by using the bit shift right operation and bitwise and operation you can extract each color value.

Wait

Wait the specified number of seconds, in other words, pausing the processor for that amount of seconds

Stop

Completely stops the processor from running, cannot be resumed in any way other than rebuilding or refreshing the code, to pause a processor disable it instead using control enable

End

End the process, when a processor run this line it will go back to 0 as if it reach the end of the instruction, similar to jump always 0

Jump

Jump to a line number on the processor with a condition
if condition are true jump to the specified line, if false does not jump (continuing to instruction below it

1. ==

Check if the 2 variables are equal to each other

2. Not

Logical not, check if the 2 variables are not equal to each other

3. <

Less than, check if the first variable is less than the second variable

4. <=

Less than equal, check if the first variable is less than equal the second variable

5. >

Greater than, check if the first variable is greater than the second variable

6. >=

Greater than equal, check if the first variable is greater than equal the second variable

7. ===

Strict equal, usually used to check for null, example:
0 == null is true, while 0 === null is false

8. Always

Always jump regardless

Controlling Units

@unit

Can only store 1 unit at any given time, stores the unit reference, like building reference, unit reference are different from each other, even the same type

Binding

unlike the name say, unit bind instruction itself does not bind, unit control, unit radar, unit locate are what binds unit.
unit bind just gets a unit's reference and puts it in a variable called @unit

If you hover your mouse on either the unit or the processor you will see a yellow box showing what unit the processor is binding or what processor the unit is binded to, this is called Binded, meaning the unit is now in full control of the processor, you cannot give it commands anymore using the RTS Commands, the only way to get the unit back is either control(posses) the unit or unbind it which can be done with either destroying the processor, or altering the processor code, units will also be automatically un-binded after 10 seconds with no unit control, unit radar, and unit locate instruction received
A unit that is currently controlled(possesed) by the player can also be "bound" but only to retrieve data from it; controlling is not possible.

Boosting

Some ground units can boost, boosting allows them to fly over anything air units can, albeit slower, these units are: Nova, Pulsar, Quasar, and Vela

Payload

Payload is a block/unit that is not physically placed in the world, they are either on a conveyor or picked up by unit,
however if you save its reference prior to making it a payload up you can still sensor data from it like @x and @y, although @dead will be true.
unit’s payload capacity can be found in-game’s info menu
Example: 3x3 means the unit can carry 9 of 1x1 blocks, 2 of 2x2 blocks and, 1 of 3x3 blocks
for units its the same, a mace size is 1.25 x 1.25 meaning it will take 1.5625 block worth of space as payload

Unit Bind

Bind 1 unit and put its reference in the @unit variable,
When binding a unit @[type] it will bind in an order
the order of bind is determined by how old it is, the first unit alive will be binded first and the most recent unit is last
When looped (meaning the unit bind instruction is run again) it will bind the next unit in the order, when it reach the end it will go back and bind the first order
Here’s a visualization : the red box indicates that the unit is in the @unit variable

Don’t worry about instruction line 1,2,3,they are there just to make the code not 1 instruction, to more easily visualize it.
Let’s say the first mega reference “mega#1”, when “mega#1” is binded it store the reference in @unit meaning @unit is now “mega#1”, and so on with “mega#2 , 3 , 4”

Unit bind can also be used with a variable that stores a unit reference to bind that specific unit directly,
for example the radar instruction can output a unit reference to a variable, you can use that variable for ubind,
another example after binding a @[type] with ubind you can save @unit to another variable, then rebind that unit with the variable

Unit Control

Unit control, controls one unit in the @unit variable, a common misconception is that it controls all binded unit, this is wrong, it might seem that way because processor loops, everytime it loops ubind it binds a new unit and controls it, it does this very fast that it looks like its controlling all unit at once.
and a second common misconception is that Unit control wait for completion before running the next unit control, this is also wrong, Like the visualization you see above, the processor doesn’t care what instruction you put in it, it will just run it regardless, it is not smart, you have to specify it yourself.

Move

Move to unit to the specified coordinates in a straight line Once the instruction is run it will move to that coordinates even if you immediately remove the instruction, its similar to RTS controls (shift clicking and left click to move unit to the cursor location)


Approach

Similar to move but it has a radius, the unit will stop at the radius



pathFind

Path find to the specified location Usually used with grounded units as Move moves the unit in a straight line and grounded units can get stuck in buildings If the specified location is inside a building or invalid the unit will not move, they will stay in place

autoPathFind

Automatically pathfinds to the nearest enemy core or drop point.
This is the same as standard wave enemy pathfinding

Idle

Stop moving, but keep building/mining, the default state

Stop

Stop moving, mining, and building

Boost

Enable boosting, boolean, 1 = boost, 0 = don’t boost. cannot be disabled if boosted unit cannot land (on top of blocks/buildings)

Target

Shoot a coordinate position, boolean, 1 = shoot, 0 = stop shooting


TargetP

Same as target but shoot a unit reference instead and with velocity prediction

ItemDrop

Drops items the unit is currently carrying to the specified location

to a building reference
amount is how many to drop
Unit have to be within (5.625 + [block size] / 2) tiles of the targeted block (from the middle), else it does nothing
Can also drop to “@air” which will discard the item anywhere
to drop everything just put a large number like 999
Unit has an interaction limit of 1,5 seconds, meaning it can only take/drop item every 1,5 seconds

ItemTake

Takes items from the specified building to the unit, unit’s item capacity can be found in-game’s info menu,
from a building reference
amount is how many to take
a unit can only carry 1 type item at a time
Unit have to be within 5.625 + [block size] / 2 tiles of the targeted block (from the middle), else it does nothing,
to take the maximum amount the unit can take just put a large number like 999,
Unit has an interaction limit of 1.5 seconds, meaning it can only take/drop item every 1.5 seconds.

PayDrop

Drop payload at current location.

PayTake

Pick up a block or a unit at current location and turn it into a payload
if multiple blocks/unit is below the taker location it will take block/unit that is closest to the taker location (taker @x and @y)
for example a unit taker location is exactly at 10,10 , there's 2 unit below it at 9.8,10 and 9.9,10 , when using paytake it will take the 9.9,10 unit

PayEnter

Land/enter on a building directly below the unit, that accept payload, like reconstructor

Mine

Mine a coordinate position, if out of range or not mineable will do nothing

Build

Build a block at specified location, if out of range or invalid will do nothing

x,y is build location
block is what block to build
rotation is what orientation the block is built, 0 is right, 1 is up, 2 is left, and 3 is down
Config, configuration of blocks, eg, if `@copper` when building a sorter will set the sorter to `@copper`. Additionally can be a building reference, eg, if `@this` when building a processor will copy `@this` processor’s code to the built processor

getBlock

Gets a block at a specified location, outputs will be null if out of range

x,y is coordinate location to get the block
type is an output, it will output the type of block to the variable
building is an output, it will output the building reference to the variable
floor is an output, it will output the type of floor to the variable

when getBlock-ing a cell,bank, or a display you can still write/draw to them even if the unit is no longer present, only the building reference is needed for these blocks, this means you can get them once and then unbind/move the unit your variable of building will remain until either you overwrite it or the processor is refreshed.
however you can't enable/disable or config getBlock-ed buildings,

Within

Check if unit is within a position with a radius

x,y is coordinate location to check if unit is within that coordinate
radius is the radius of the within
returns boolean
result is the result, 0 / 1, true / false
Example: (the @unit variable is mega shown on the picture)


In this two scenario, the first picture will have the variable `result` true because the unit is within the circle, while the second picture is false because it is outside the circle

Unbind

Immediately unbind unit

Flag

Gives the unit a numeric flag, essentially assigning a number to a unit, this number serves no purpose other than being read, what you do with the number is up to you
the flag "lives" in the unit, meaning a unit will permanently retains its flag until written again, even if the processor is destroyed
Unit default flag is 0
a unit can only store 1 numeric flag
The largest integer that can be stored accurately is 2^53 which is 9007199254740992 and 2^-53 which is -9007199254740992. Beyond these limits, representation may lead to inaccuracies due to the way numbers are rounded.

Unit Radar


Unit radar locates other unit around the @unit unit within the unit’s range (information can be found in-game’s info menu)
target is a filter of what category of unit it will radar, enemy means it will radar enemy units
Order is sorting order, ascending or descending, can only be 0 or 1
sort is a metric to sort results by, distance means it will get unit by distance
Since order is 1, the unit gotten is the closest to that @unit’s unit
Will output the unit reference to `result`.
sort distance order 1 = closest, 0 = furthest
sort health, maxHealth, armor, shield order 1 = highest, 0 = lowest

Unit Locate

Locates a building/ore/spawn without needing to be in the unit’s range, but limited to what it can locates

Building

Will locate a building of the selected group, in this case, core,

Enemy is whether to locate enemy building’s or not, true means it will locate enemy’s building, false means it will locate ally building
outX and outY are the building’s output coordinates
Found is an output on whether the building is found(exist in the map) or not, true means it is found, false means it is not found Building is an output of that building reference

Ore


Will locate an ore of the selected type, in this case @copper

Spawn

Will locate an enemy spawn point, may be a core or a position

Damaged

Will locate an enemy spawn point, may be a core or a position

Simple Logic examples

Shuttle Logic

Line 0 : bind a flare
Line 1 : locate an ally core, outputs its coordinates to `cx,cy`, and building reference to `core`
Line 2 - 3 : get the coordinates of the linked vault using sensor
Line 4 : sensoring the @totalItems from @unit to get the amount of items the unit are currently carrying
Line 5 : a conditional jump, jump to (move to core) and take item if the item the unit are currently carrying is 0
Else jump to move to (vault and drop item)
Line 6-7: move to vault and take item from vault
Line 8 : end, to make sure both (move to core) and (move to vault) cannot run in the same time
Line 9-10 : move to core and take @copper from core

The key is to not put 2 or more move that the processor can run “simultaneously”, in other words don’t make the unit move to 2 location or more “simultaneously” Either move to core or move to vault based on a condition

Thorium Reactor Fail Safe

line 0 : getlink with `i`, which is an incrementing variable, writes the result to `block`
line 1 : sensor for cryofluid in `block`, writes the result to `cryo`
line 2 : compare if `cryo` > (greater than) 15, if it is `fail` will be true, else `fail` will be false
line 3 : control `block` to `fail` which controls the thorium reactors to `fail`, if line 2 is true then `fail` is true, thus enabling the thorium reactor
line 4 : incrementing the variable `i`
line 5 : resets the variable `i` when it reached `@links` using the % operator

Advanced

Writing in text editor

Mlog are essentially plain text, this means you can use any text editor to write mlog, including Notepad
Here are some things that makes it easier to write in plain text:
In these example i will be using Visual Studio Code with “Mindustry Logic” extension

a new VS Code extension for Mlog is available at “Mindustry Logic for VSCode”, made by JeanJPNM . This extension brings actual support for mlog, like syntax highlighting, intellisense, diagnostic messages, and more, if you’re writing with VSCode I recommend checking this out.

Lables

Labels are replacement for jumps number, this way you can write freely without needing to worry about jump numbers

Comments

Comments will be removed when importing the code to the game

Combining lines

You can combine lines with “ ; “

Tabs and newlines

Tabs and newlines will also be removed when importing the code to the game, this is just for better readability

List of mlog instruction in text form

World Logic

World processor are processor that controls how the world behave, they have every instruction a normal processor have plus world instruction
They have unlimited range
They can link and control every buildings including enemy’s
they can bind and control every units including enemy’s
Maximum IPT of a world processor is 500, which can be set using Set Rate

Get block



“result” the output
`get` what to get, can be:
“floor” get the floor name of the specified coordinate
“ore” get the ore name of the specified coordinate
“block” get the block name of the specified coordinate
“building” get the building reference of the specified coordinate
`at` x and y coordinate respectively

Set Block



`set` what type to set, can be :
“floor” set the floor to the specified name and Coordinate
“ore” set ore to the specified name and coordinate
“block” set block to the specified name and coordinate
name can be found on Environment
`at` x and y coordinate respectively
`team` what them to set the block to, can be team name or a number 0 - 255

Spawn Unit



“result”, the output, unit reference
`spawn` what unit to spawn
`at` x and y coordinate respectively
`team` what them to set the block to, can be team name or a number 0 - 255
`rot` rotation (facing what direction) of the spawned unit, in degrees, for reference : 360/0 is right, 90 is up

Apply Status



`apply` or `clear`, apply or clear
`wet` what status to apply to the unit
`to` unit, unit reference
`for` duration of the status

Spawn Wave



Set Rule



currentWaveTime
change the current wave timer, in seconds
waveTimer
waves
wave
set wave number
waveSpacing
change the timer for the next wave, in seconds
waveSending
attackMode
enemyCoreBuildRadius
set how large the radius of the no build zone around the enemy core
dropZoneRadius
set how large the annihilation radius around the enemy spawn point
unitCap
set the cap of unit that can be constructed
mapArea
set the size of the playable field in the map/sector
starts at the bottom left
`x` and `y` is the offset from 0,0
`width` and `height` is the size of the map, calculated from the offset
lightning
boolean, whether to enable lightning or not, if disabled all section of the map (other solid walls) will be fully bright
ambientLight
set the ‘dark’ part of light colors, in other words change colors of shadows
solarMultiplier
set the multiplier solar panels produce power
unitBuildSpeed
set the build speed of units
unitHealth
set the multiplier of unit health, does not actually change unit max health, increase resistance instead, actual damage received = (damage received / unitHealth) as for ‘damage received’ check damage calculation
unitCost
set multiplier of unit construction cost
unitDamage
set the multiplier of unit damage
blockHealth
set the multiplier of block health
blockDamage
set the multiplier of block damage (turrets, explosion, etc)
rtsMinWeight
rtsMinSquad

Flush Message



display a message on player’s screen from the text buffer, will wait until the previous message finishes

`announce` center of the screen


`notify` top of the screen


`toast`


`mission`


Cut scene

manipulate the camera, players cannot move/interact in this mode
does not have duration cutscene will stays until `cutscene stop` is used
`pan` moves the camera to the specified coordinates, with specified speed
`zoom` zooms the camera, value is from 0 to 1, although can be more it is limited by the game, this limit is the same as your manual zoom limit, when used not with `pan` will zoom to 0,0 instead
`stop` stops previous cutscene

Effect



display a particle effect on the world, you can click the `warn` to view every available effect

Explosion



create an explosion
`team` what team the explosion belong to, explosion cannot harm ally blocks
`x` `y` where to create the explosion
`radius` size of explosion, block outside this radius does not take damage
`damage` the damage of the explosion
`air` whether to damage air or nor, true means it will damage air (air units, boosted units, etc)
`ground` whether to damage ground or nor, true means it will damage ground (ground unit, blocks, etc)
`pierce` whether to pierce buildings or not, if false, it will need a line of sight from the explosion to the block, if something is in the way that block will not be damaged

Set Rate



Set the speed of the processor, in instruction per tick, 1 second = 60 ticks

Fetch



get unit, player, core, building, and outputs their reference to “result”, by index
`team` what team to fetch the object
`#` index, starts at 0, 0 being the first object
unitCount, playerCount, coreCount, buildCount, gets the total count of currently alive/available object in the world
when an object dies the last object index will replace the object index that dies
for example: you have 10 conveyors indexed from 1-10, conveyor #5 is deconstructed, conveyor
#10 will the become #5, then a new placed conveyor will become #10

Sync



sync a variable across all devices, used mainly in multiplayer, to avoid desyncing

Set Flag



set a global flag / global variable, flag content can only be 0 or 1, true or false
flag name is enclosed by ` " `
this flag can be read anywhere in the map using the get flag instruction

Get Flag



read the flag/variable created by set flag
reads the content of the flag
writes the result the the result variable

Set Prop



sets the properties of a unit or building
`of` unit/building Reference
`to` value

Bleeding Edge

Bleeding edge is the newest test version of mindustry, like Early Access or Beta Build
BE version can be found and downloaded on https://github.com/Anuken/MindustryBuilds

BE feature are subject to change, therefore i cannot make sure these information are up to date

Draw image

Draw image now supports more contents, like floors (@salt, @ice) and more

Draw print

Draw text from the print buffer. only ASCII characters allowed. clears the print buffer. still needs to be draw flushed

Draw Translate

Translate / offset the display coordinates, this instruction is cumulative, meaning it translate it by the specified number every flush.
example: you draw something at 20, 20, running and flushing translate 10,10 will offset the display coordinates by 10, so your (draw at 20,20) is now appeared as it was drawn on 30,30.
like said above it is cumulative, if you run and flush translate 10, 10 again it will offset it again by 10, so your (draw at 20,20) is now appeared as it was drawn on 40,40.
to reset it use draw reset

Draw Scale

scale the display coordinates / zooms it, this is also cumulative.
example: you draw a rectangle at 20, 20 with width and height of 20, 20, if you draw scale 2, 2 the rectangle will appear 2 times bigger / appeared as it was drawn with width and height of 40, 40.
if you run and flush scale 2, 2 again it will scale it again by 2 times again.
running scale 1,2 will work as you expected, scaling the y while not scaling the x.

Draw Rotate

self explanatory, rotate the display coordinates by a degree, also cumulative.

Draw Reset

resets all previous translate,scale,and rotate / will make your display coordinates normal / as it was like a new one.

Format

allows you to print a variable or something else inside a string, if you know python it's similar to
f”string text {variable}”, where `variable` can be anything, int, float, or another string.

the pattern is {0-9}

example:

the first format will take {0} and the second format will take {1}

Play Sound

plays a sound from the game’s sfx, include all of the game’s .ogg file, can be found in sounds folder.
volume controls the volume of the played sound.
pitch change the pitch of the played sound, .
the formula is, pitch = 2 ^ ([semitone change] / 12 ).
for example @sfx-press tone is c4 to make it c5 meaning increase it by 12 semitone :
2 ^ (12 / 12) = 2
or c6 : 2 ^ (24 / 12) = 4
or c3 : 2 ^ (-12 / 12) = 0.5
pan pans the sound to the left or right
limit, if true prevents sound from being played if the sound has already played in the same frame, this prevents ear destroying sounds

Weather Sense

sense the current weather is the specified weather type, returns boolean

Weather Set

set the current state of the weather to the specified type

Make Marker

Makes a Marker
a marker is an entity in the map that shows content to the user, for example when you select a unit (shift + drag click) a diamond shaped box appear around that unit, that is a marker, or when you tell a unit to move a line appears, that is also considered a marker, the floating text in the beginning tutorial is also a marker.

id is numeric identity of the Marker, id can be from 0 to 19999
meaning a world/map can only have 20.000 markers
game created markers like the examples above doesn't intervere with player made markers

replace determines whether this marker will replace exsisting previous markers that has the same id
currently there is a bug with the replace argument where it replaces other markers than the specified id
it is recommended to just keep it false

Texture, makes a marker for a Texture.
initially invisible until texture is defined, using setmarker texture.
texture can be anything that is available in the game.

Quad, are quadrilateral / a 4 sided polygon.
a quad has 4 vertices and 4 sides.
each vertices position can be set using setmarker posi.

texture is initially just pure white, can be defined with setmarker texture,
then needs to be further defined with setmarker uvi to set the texture location within the quad.

Set Marker

Sets a property of a marker with the specified id.

texture, sets the texure of a marker.
the `printFlush` argument are boolean,
when true it uses the text in the text buffer as the name,
otherwise uses the `name` argument.
name can game content name, like @router, or @surge-alloy, if doesn't work use file name instead.
can also be file name, like "item-copper", when using a file name remember to put them in quotes,
file names can be found on https://github.com/Anuken/Mindustry/tree/master/core/assets-raw/sprites

posi, sets the vertices location of a quad, location are world x,y location
with index from 0-3
each index repesents each vertices

uvi, sets each vertices of the texture relative to the quad (UV Mapping with index)
with index from 0-3
each index repesents each vertices, example:
#0 (0,0)
#1 (1,0)
#2 (1,1)
#3 (0,1)
will sets each texture vertices exactly where the quad vertices are, this means texture will stretch/reform to the quad shapes

colori, similar to uvi, if indexes are set to different colors; color will gradient from one to the other
with index from 0-3
each index repesents each vertices, example:
#0 (0,0)
#1 (1,0)
#2 (1,1)
#3 (0,1)
will set
color, change the color of the marker.
color only tints the color of the marker,
meaning a marker that already has a color, like setting the color of a texture to white doesn't effect them, it will appear as its original texture color,
since quad doesn't have a color quad will take the full color the specified color.

Locale Print

@cameraWidth and @cameraHeight

an object camera width/height, usually the players possesed object, eg turrets/units
the width/height numbers are in blocks
example:
`sensor width @unit @cameraWidth`, where @unit is the player
a maxed zoomed out screen on a 1080x1920 screen width is 40, which means the viewable width is 40 blocks
if the object is not a player/doesn't have a camera returns 0

@cameraX and @cameraY

an object x/y camera location
the x/y numbers are in the map coordinate system
example:
`sensor x @unit @cameraX`, where `@unit` is the player
while moving the camera returns the camera position in the map coordinate location
different from sensoring `@x` since you can move the camera independently of the unit

@solid

an object solidness
example:
`sensor s conveyor1 @solid`
returns `s` as 0
while a wall for example returns 1

@velocityX and @velocityY

an object velocity, in blocks/second
example:
`sensor vx @unit @velocityX`
returns `vx` as a number of the @unit velocity in blocks/second
can also be think of as a vector,
by using `op len` on the @unit's @velocityX and @velocityY you can get the unit current speed
this variable also avaiable in `setprop`

Extras

These are niche question that very small number of people might have

Self Promotion

My Micro Processor only Bad Apple!!!

Raycasting and DDA Raycasting

Perspective Projection

Power Monitor with Numbers

Appendix

Mlog Invention

Disabled block Behaviour

Most blocks will just stop working entirely, however not all, here are some blocks that behave differently when disabled
• Sorter will turn into inverted sorter, which can be used as a item flow controller


• Inverted sorter will turn into normal sorter, which can be used as a item flow controller


• Overflow gate will turn into Underflow gate, which can be used as a item flow controller


• Underflow gate will turn into Overflow gate, which can be used as a item flow controller


• Router will stop items from passing through


• Bridge will stop transfering items, but still accepts items


• Battery will stop charging but still conduct electricity


• Blocks with electricity will stop working but still conduct electricity


• Battery Diode Will stop flowing electricity to the other net, can be used as a power line cutter


• Turrets Will just stop (shooting, moving), will still accept ammo


• Launch Pad if its in cooldown will stop cooldown from progressing, still accepts items
  if its not in cooldown will still launch if items are full


• Processors will stop executing lines, when re-enabled will continue at the line it was disabled at