Modding

Mindustry mods are simply directories of assests. There are many ways to use the modding API, depending on exactly what you want to do, and how far you're willing to go to do it.

You could just resprite existing game content, you can create new game content with the simpler Json API (which is the main focus of this documentation), you can add custom sounds (or reuse existing ones). It's possible to add maps to campaign mode, and add scripts to program special behavior into your mod, like custom effects.

Sharing your mod is as simple as giving someone your project directory; mods are also cross platfrom to any platform that supports them. Realistically speaking you'll want to use GitHub, you should also checkout the Example Mod repository on GitHub: https://github.com/Anuken/ExampleMod

To make mods all you really need is any computer with a text editor.

Directory Structure

Your project directory should look something like this:

project
├── mod.json
├── content
│   ├── items
│   ├── blocks
│   ├── mechs
│   ├── liquids
│   ├── units
│   └── zones
├── maps
├── bundles
├── sounds
├── schematics
├── scripts
├── sprites-override
└── sprites
  • mod.json (required) metadata file for your mod,
  • content/* directories for game Content,
  • maps/ directory for Zone maps,
  • bundles/ directory for Bundles,
  • sounds/ directory for Sound files,
  • schematics/ directory for Schematic files,
  • scripts/ directory for Scripts,
  • sprites-override/ Sprites directory for overriding ingame content,
  • sprites/ Sprites directory for your content,

Every platform has a different user application data directory, and this is where your mods should be placed:

  • Linux: ~/.local/share/Mindustry/mods/
  • Steam: steam/steamapps/common/Mindustry/mods/
  • Windows: %appdata%/Mindustry/mods/
  • Apple: ~/Library/Application Support/Mindustry/mods/

Note that your filenames should be lowercased and hyphen separated:

  • correct: my-custom-block.json
  • incorrect: My Custom Block.json

Hjson

Mindustry uses Hjson, which for anyone who knows Json, is simply a superset of the very popular serialization language known as Json. – This means that any valid Json will work, but you get extra useful stuff:

# single line comment

// single line comment

/* multiline
comment */

key1: single line string

key2:
'''
multiline
string
'''

key3: [ value 1
        value 2
        value 3 ]

key4: { key1: string
        key2: 0 }

If you don't know any of those words. – A serialization language, is simply a language which encodes information for a program, and encode means to translate informantion from one form to another, and in this case, to translate text into Java data structures.

mod.json

At the root of your project directory, you must have a mod.json which defines the basic metadata for your project. This file can also be (optionally) named mod.hjson to potentially help your text editor pick better syntax highlighting.

name: Mod Name
displayName: Mod [red]Name[]
author: Yourself
description: This is a useless description.
version: "1.0"
minGameVersion: "100.3"
dependencies: [ ]
  • name will be used to reference to your mod, so name it carefully;
  • displayName this will be used as a display name for the UI, which you can use to add formatting to said name;
  • description of the mod will be rendered in the ingame mod manager, so keep it short and to the point;
  • dependencies is optional, if you want to know more about that, go to the dependencies section;
  • minGameVersion is the minimum build version of the game.

Content

At the root of your project directory you can have a content/ directory, and this is where all the Json/Hjson data goes. Inside of content/ you have subdirectories for the various kinds of content, these are the current common ones:

  • content/items/ for items, like copper and surge-alloy;
  • content/blocks/ for blocks, like turrets and floors;
  • content/mechs/ for mechs, like tau and glaive;
  • content/liquids/ for liquids, like water and slag;
  • content/units/ for flying or ground units, like reaper and dagger;
  • content/zones/ for zones, configuration of campaign maps.

Note that each one of these subdirectories needs a specific content type. The filenames of these files is important, because the stem name of your path (filename without the extension) is used to reference it.

Furthermore the files within these content/<content-type>/* directories may be arbitrarly nested into other sub-directories of any name, to help you organize them further, for example:

  • content/items/metals/iron.hjson, which would respectively create an item named iron.

The content of these files will tend to look something like this:

type: TypeOfThing
name: Name Of Thing
description: Description of thing.
# ... more fields here ...
field type notes
type String Content type of this object.
name String Displayed name of content.
description String Displayed description of content.

Other fields included will be the fields of the type itself.

Types

Types have numerous fields, but the important one is type; this is a special field used by the content parser, that changes which type your object is. A Router type can't be a Turret type, as they're just completely different.

Types extend each other, so if MissileBulletType extends BasicBulletType, you'll have access to all the fields of BasicBulletType inside of MissileBulletType like damage, lifetime and speed. Fields are case sensitive: hitSize =/= hitsize.

What you can expect a field to do is up to the specific type, some types do absolutely nothing with their fields, and work mostly as a base types will extend from. One such type is Block.

type can be refer to the actual type field of the object. A type may also refer to other things like float is a type so it means you can type 0.3 in a field.

Here you can see, the type of the top level object is Revenant, but the type of the bullet is BulletType so you can use MissileBulletType, because MissileBulletType extends BulletType.

type: Revenant
weapon: {
  bullet: {
    type: MissileBulletType
    damage: 9000
  }
}

Tech Tree

Much like type there exist another magical field known as research which can go at the root of any block object to put it in the techtree.

research: duo

This would put your block after duo in the techtree, and to put it after your own mods block you would write your <block-name>, a mod name prefix is only required if you're using the content from another mod.

Research cost will be 40 + round(requirements ^ 1.25) * 6 rounded down to the nearest 10, where requirements is the build cost of your block. (in otherwords you can't set requirements and research cost individually)

Sprites

All you need to make sprites, is an image editor that supports transparency (aka: not paint). Block sprites should be 32 * size, so a 2x2 block would require a 64x64 image. Images must be .png files with 32 bit depth.

Sprites can simply be dropped in the sprites/ subdirectory. The content parser will look through it recursively, so you can organize them how ever you feel.

Content is going to look for sprites relative to it's own name. content/blocks/my-hail.json has the name my-hail and similarly sprites/my-hail.png has the name my-hail, so it'll be used by this content.

Content may look for multiple sprites. my-hail could be a turret, and it could look for the suffix <name>-heat and what this means is it'll look for my-hail-heat.

You can find all the vanilla sprites here:

Another thing to know about sprites is that some of them are modified by the game. Turrets specifically have a black border added to them, so you must account for that while making your sprites, leaving transparent space around turrets for example: Ripple

To override ingame content sprites, you can simply put them in sprites-override/.

Sound

Custom sounds can be added through the modding system by dropping them in the sounds/ subdirectory. It doesn't matter where you put them. Two formats are needed:

  • .ogg required for Desktop/Android
  • .mp3 required for iOS

Just like any other assets, you reference them by the stem of your filenames, so pewpew.ogg and pewpew.mp3 can be referenced with pewpew from a field of type Sound.

Here's a list of built-in sounds:

  • artillery
  • back
  • bang
  • beam
  • bigshot
  • boom
  • break
  • build
  • buttonClick
  • click
  • conveyor
  • corexplode
  • door
  • drill
  • empty
  • explosionbig
  • explosion
  • fire
  • flame2
  • flame
  • laserbig
  • laser
  • machine
  • message
  • missile
  • pew
  • place
  • press
  • release
  • respawning
  • respawn
  • shootBig
  • shoot
  • shootSnap
  • shotgun
  • spark
  • splash
  • spray
  • thruster
  • unlock
  • wave
  • windowHide

Dependencies

You can add dependencies to your mod by simple adding other mods name in your mod.json:

dependencies: [
  other-mod-name
  not-a-mod
]

The name of dependencies are lower-cased and spaces are replaced with - hyphens, for example Other MOD NamE becomes other-mod-name.

To reference the other mods assets, you must prefix the asset with the other mods name:

  • other-mod-name-not-copper would reference not-copper in other-mod-name
  • other-mod-name-angry-dagger would reference angry-dagger in other-mod-name
  • not-a-mod-angry-dagger would reference angry-dagger in not-a-mod

Bundles

An optional addition to your mod is called bundles. The main use of bundles are give translations of your content, but there's no reason you couldn't use them in English. These are plaintext files which go in the bundles/ subdirectory, and they should be named something like bundle_ru.properties (for Russian).

The contents of this file is very simple:

block.example-mod-silver-wall.name = Серебряная Стена
block.example-mod-silver-wall.description = Стена из серебра.

If you've read the first few sections of this guide, you'll spot it right away:

  • <content type>.<mod name>-<content name>.name
  • <content type>.<mod name>-<content name>.description

Notes:

  • mod/content names are lowercased and hyphen separated.

List of content type:

  • item
  • block
  • mech
  • bullet
  • liquid
  • status
  • unit
  • weather
  • effect
  • zone
  • loadout
  • typeid

List of filenames relative to languages:

  • English bundle.properties
  • Czech bundle_cs.properties
  • German bundle_de.properties
  • Spanish bundle_es.properties
  • Estonian bundle_et.properties
  • Basque bundle_eu.properties
  • French BE bundle_fr_BE.properties
  • French bundle_fr.properties
  • Bergabung bundle_in_ID.properties
  • Italian bundle_it.properties
  • Japanese bundle_ja.properties
  • Korean bundle_ko.properties
  • Dutch BE bundle_nl_BE.properties
  • Dutch bundle_nl.properties
  • Polish bundle_pl.properties
  • Portuguese BR bundle_pt_BR.properties
  • Portuguese bundle_pt.properties
  • Russian bundle_ru.properties
  • Danish bundle_sv.properties
  • Turkman bundle_tk.properties
  • Turkish bundle_tr.properties
  • Ukrainian bundle_uk_UA.properties
  • Chinese CN bundle_zh_CN.properties
  • Chinese TW bundle_zh_TW.properties

Markup

The text renderer uses a simple makeup language for coloring text.

  • [name] sets the color by name, there's a few built-in colors;
  • [#rrggbb] / [#rrggbbaa] sets the color by hex value, with each value being anything from 00 to ff:
    • rr is the red value,
    • gg is the green value,
    • bb is the blue value,
    • aa is the alpha value;
  • [] sets the color back to the previous color;
  • [[ escapes the left bracket, so you can write [[red] to write and it'll render as [red].

Notes:

  • erros/unknown colors will be silently ignored.

Example:

[red]red
[#ff0000]full-red
[#ff000066]half-red
[#ff000033]half-half-red
[#00ff00]green
[]half-half-red

Built-in Colors

[clear]clear
[black]black
[white]white
[lightgray]lightgray
[gray]gray
[darkgray]darkgray
[blue]blue
[navy]navy
[royal]royal
[slate]slate
[sky]sky
[cyan]cyan
[teal]teal
[green]green
[acid]acid
[lime]lime
[forest]forest
[olive]olive
[yellow]yellow
[gold]gold
[goldenrod]goldenrod
[orange]orange
[brown]brown
[tan]tan
[brick]brick
[red]red
[scarlet]scarlet
[coral]coral
[salmon]salmon
[pink]pink
[magenta]magenta
[purple]purple
[violet]violet
[maroon]maroon

Schematic

Fields that require the type Schematic can either take a built-in loadout (see the Zone section) a base64 string, or the stem name of a .msch file in the schematics/ subdirectory.

As of now, the only purpose of schematics is to give a zone a loadout.

Scripts

Scripting in Mindustry is done with the Rhino JavaScript runtime. Scripts may be added to your mod by putting them in scripts/. Using the built-in extendContent function, you can extend existing Java types from JS, using allowed classes which are injected into your namespace.

For example:

  • scripts/silo.js

    // create a simple shockwave effect
    const siloLaunchEffect = newEffect(20, e => {
    
        // color goes from white to light gray
        Draw.color(Color.white, Color.lightGray, e.fin());
    
        // line thickness goes from 3 to 0
        Lines.stroke(e.fout() * 3);
    
        // draw a circle whose radius goes from 0 to 100
        Lines.circle(e.x, e.y, e.fin() * 100);
    });
    
    // create the block type
    const silo = extendContent(Block, "scatter-silo", {
    
        // override the method to build configuration
        buildConfiguration(tile, table) {
            table.addImageButton(
                Icon.arrowUpSmall,
                Styles.clearTransi,
    
                // configure the tile to signal that it has been
                // pressed (this sync on client to server)
                run(() => tile.configure(0))
            ).size(50);
        },
    
        // override configure event
        configured(tile, value) {
    
            // make sure this silo has the items it needs to fire
            if (tile.entity.cons.valid()) {
    
                // make this effect occur at the tile location
                Effects.effect(siloLaunchEffect, tile);
    
                // create 10 bullets at this tile's location with
                // random rotation and velocity/lifetime
                for (var i = 0; i < 10; i++) {
                    Calls.createBullet(
                        Bullets.flakExplosive,
                        tile.getTeam(),
                        tile.drawx(),
                        tile.drawy(),
                        Mathf.random(360),
                        Mathf.random(0.5, 1.0),
                        Mathf.random(0.2, 1.0)
                    );
                }
    
                // triggering consumption makes it use up the
                // items it requires
                tile.entity.cons.trigger();
            }
        }
    });
    
  • content/blocks/scatter-silo.hjson

    localizedName: "Scatter Silo"
    description: "A player-activatable block that scatters bullets everywhere upon use."
    
    category: turret
    size: 2
    
    update: true
    solid: true
    hasItems: true
    configurable: true
    
    requirements: [ "graphite/75"
                    "titanium/30" ]
    
    consumes: { items: { items: [ "scrap/10" ] } }
    

More examples:

GitHub

Once you have a mod of some kind, you'll want to actually share it, and you may even want to work with other people on it, and to do that you can use GitHub. If you don't know what Git (or GitHub) is at all, then you should look into GitHub Desktop, otherwise simply use your favorite command line tool or text editor plugin.

All you need understand is how to open repositories on GitHub, stage and commit changes in your local repository, and push changes to the GitHub repository. Once your project is on GitHub, there are three ways to share it:

  • with the endpoint, for example Anuken/ExampleMod, which could then be typed in the ingame GitHub interface, and that would download it;
  • with the zip file, for example https://github.com/Anuken/ExampleMod/archive/master.zip, which would download the repository as a zip file, and put in mod directory (unzipping is not required);
  • add the typic/tags mindustry-mod on your repository, which should cause the #mods Discord bot to pick it up and render it in it's listh.

FAQ

  • time in game is calculated through ticks;
  • ticks sometimes called frames, are assumed to be 60/1 second;
  • tilesize is 8 units internally;
  • to calculate range out of lifetime and speed you can do lifetime * speed = range;
  • Abstract what is abstract? all you need to know about abstract types, is this is a Java specific term, which means you cannot instantiate/initialize this specific type by itself. If you do so you'll probably get an "initialization exception" of some kind;
  • what is a NullPointerException? This is an error message that indicates a field is null and shouldn't be null, meaning one of the required fields may be missing;
  • bleeding-edge what is bleeding-edge? This is the developer version of Mindustry, specifically it's refering to the Github master branch. Changes on bleeding-edge usually make it into Mindustry in the next release.

Change Log

This is a log of changes done on the Mindustry Master branch that affected the modding API. The sections are ordered by date commited, and provide a description of what was changed, with a link to the diff on Github.

2020

Mar 5

[ commit Tech tree balance ]

  • updated research cost formula

Feb 11

[ commit improved battery brightness display ]

  • added <name>-top region for battery;

Jan 24

[ commit fixed #1436 / fixed crawlers not exploding ]

  • added instantDisappear to BulletType;

Jan 23

[ commit implemented #1093 ]

  • added attribute to ThermalGenerator;

Jan 22

[ commit added default ore flags for modded ores ]

  • added oreDefault, oreThreshold and oreScale to Floor;

Jan 19

[ commit cleanup of scripts ]

  • added killShooter attribute for BulletType;

Jan 14

[ commit visual tweaks ]

  • added -spinner region to Separator;
  • removed spinnerRadius, spinnerLength, spinnerThickness, color from Separator;

Jan 08

[ commit make rebuildable a block attribute (#1338) ]

  • added rebuildable to Block;

Jan 07

[ commit cleanup ]

  • added drawCell, drawItems and drawLight to Mech;

Jan 04

[ commit merge remote-tracking branch 'origin/master' ]

  • added targetDistance to Weapon;

Jan 03

[ commit use findAll to iterate through mod content ]

  • content/ support for organizing .hjson files into directories;

2019

Dec 12

[ commit add liquid void block ]

  • added LiquidVoid block;

Dec 09

[ commit Removed unnecessary unit types ]

  • changed unit types names:
    • DraugMinerDrone;
    • SpiritRepairDrone;
    • PhantomBuilderDrone;
    • [ Dagger Crawler Titan Fortress Eruptor ] → GroundUnit;
    • [ Wraith Ghoul ] → FlyingUnit;
    • RevenantHoverUnit;

Dec 08

[ commit Merge branches master and rhino-js-suffering ]

  • scripts/ sub-directory and Rhino JS runtime was added;
  • displayName can now be used as field name in mod.json

Dec 04

[ commit Added experimental server block syncing ]

  • sync field for Block type was added;

Nov 26

[ commit Texture overrides / Potential mod texture binding optimizations ]

  • sprites-override/ subdirectory can now be used to override existing ingame sprites;

Nov 22

[ commit Switched to hjson extension ]

  • .hjson can now be used as a file extension;

Nov 22

[ commit Added optional mod minimum game version ]

  • minGameVersion can now be used within mod.json;

Nov 20

[ commit Better mod parsing ]

  • liquid/amount can now be used as a string for LiquidStack;
  • item/amount can now be used as a string for ItemStack;
  • mod.json now supports hjson;

World

Block

Extends BlockStorage

Block is the base type of all blocks in the game. All blocks have at least one sprite, which is picked relative to the blocks name.

Fields for all objects that are blocks.

field type default notes
update boolean   whether this block has a tile entity that updates
destructible boolean   whether this block has health and can be destroyed
unloadable boolean true whether unloaders work on this block
solid boolean   whether this is solid
solidifes boolean   whether this block CAN be solid.
rotate boolean   whether this is rotateable
breakable boolean   whether you can break this with rightclick
rebuildable boolean true whether to add this block to brokenblocks or not (like ShockMine or NuclearReactor)
placeableOn boolean true whether this floor can be placed on.
insulated boolean false whether this block has insulating properties.
health int -1 tile entity health
baseExplosiveness float 0 base block explosiveness
floating boolean false whether this block can be placed on edges of liquids.
size int 1 multiblock size; 1 makes the block 1x1, 2 makes the block 2x2, and so on.
expanded boolean false Whether to draw this block in the expanded draw range.
timers int 0 Max of timers used.
cacheLayer CacheLayer normal Cache layer. Only used for 'cached' rendering.
fillesTile true   Special flag; if false, floor will be drawn under this block even if it is cached.
alwaysReplace boolean false whether this block can be replaced in all cases
group BlockGroup none Unless canReplace is overriden, blocks in the same group can replace each other.
priority TargetPriority base Targeting priority of this block, as seen by enemies.
configurable boolean   Whether the block can be tapped and selected to configure.
consumesTap boolean   Whether this block consumes touchDown events when tapped.
drawLiquidLight boolean true Whether to draw the glow of the liquid for this block, if it has one.
posConfig boolean   Whether the config is positional and needs to be shifted.
sync boolean   Whether to periodically sync this block across the network.
targetable boolean true Whether units target this block.
canOverdrive boolean true Whether the overdrive core has any effect on this block.
outlineColor Color 404049 Outlined icon color.
outlineIcon boolean false Whether the icon region has an outline added.
hasShadow boolean true Whether this block has a shadow under it.
breakSound Sound boom Sounds made when this block breaks.
activeSound Sound none The sound that this block makes while active. One sound loop. Do not overuse.
activeSoundVolume float 0.5 Active sound base volume.
idleSound Sound none The sound that this block makes while idle. Uses one sound loop for all blocks.
idleSoundVolume float 0.5 Idle sound base volume.
requirements [ ItemStack ]   Cost of constructing and researching this block.
category Category distribution Category in place menu.
buildCost float   Cost of building this block; do not modify directly!
buildVisibility BuildVisibility hidden Whether this block is visible and can currently be built.
buildCostMultiplier float 1 Multiplier for speed of building this block.
instantTransfer boolean false Whether this block has instant transfer.
alwaysUnlocked boolean false  
layer Layer null Layer to draw extra stuff on.
layer2 Layer null Extra layer to draw extra stuff on.

Sprites:

  • <name> the main sprite for the block.

Consumers

This type is commonly used in block type with it's field consumes, it's a type that allows your block to consume something, and how this field works is up to the specific type extension you're using.

field type notes
item String shorthand for items
items ConsumeItems consume a number of different items
liquid ConsumeLiquid consume a single liquid
power float or ConsumePower consume or buffer power
powerBuffered float amount of power buffered

Notes:

  • you shouldn't have power and powerBuffered.

For example with ConsumeItems and ConsumeLiquid:

items: {
  items: [
    copper/10
    surge-alloy/5
  ]
  booster: true
  optional: true
}
liquid: {
  water/1.0
}

Consume

Abstract type which defines a type of resource that a block can consume.

field type default notes
optional boolean   consumer will not influence consumer validity.
booster boolean   consumer will be displayed as a boost input.
update boolean true  

ConsumeItems

Extends Consume

Type to consume ItemStacks.

field type
items [ ItemStack ]

ConsumeLiquid

Extends Consume

Type to consume a LiquidStack.

field type default notes
liquid String   the name of liquid type consumed
amount float   amount used per frame
timePeriod float 60 how much time is taken to use this liquid, example: a normal ConsumeLiquid with 10/s and a 10 second timePeriod would display as 100 seconds, but without a time override it would display as 10 liquid/second. This is used for generic crafters.

ConsumePower

Extends Consume

Type to consume or buffer power.

field type notes
usage float The maximum amount of power which can be processed per tick. This might influence efficiency or load a buffer
capacity float The maximum power capacity in power units.
buffered boolean True if the module can store power.

BlockStorage

Abstract type that extends Content

Type for blocks which may store a buffer of items or liquid.

field type default
hasItems boolean  
hasLiquids boolean  
hasPower boolean  
outputsLiquid boolean false
consumesPower boolean true
outputsPower boolean false
itemCapacity int 10
liquidCapacity float 10
item float 10
liquidPressure float 1
consumes Consumers  

Environment

Environmental blocks are blocks that must be placed from the editor, and they're the ones that will generally dictate how the game can or will be played. These blocks wont appear on a map unless you've built a map to support them.

Floor

Extends Block

Type used for floors themselves or extended to make ores and other things.

field type default notes
variants int 3 number of different variant regions to use.
edge String stone edge fallback, used mainly for ores.
speedMultiplier float 1 multiplies unit velocity by this when walked on.
dragMultiplier float 0 multiplies unit drag by this when walked on.
damageTaken float 0 damage taken per tick on this tile.
drownTime float 0 how many ticks it takes to drown on this.
walkEffect Effect ripple effect when walking on this floor.
drownUpdateEffect Effect bubble effect displayed when drowning on this floor.
status StatusEffect none status effect applied when walking on.
statusDuration float 60 intensity of applied status effect.
liquidDrop Liquid   liquids that drop from this block, used for pumps.
itemDrop Item   item that drops from this block, used for drills.
isLiquid boolean   whether this block can be drowned in.
playerUnmineable boolean false block cannot be mined by players if true.
blendGroup Block this group of blocks that this block does not draw edges on.
updateEffect Effect none effect displayed when randomly updated.
attributes Attributes   array of affinities to certain things.
oreDefault boolean false whether this ore generates in maps by default.
oreScale float 24 ore generation param, for example thorium is 25.38, copper is 23.47.
oreThreshold float 0.828 ore generation param, for example thorium is 0.882, copper is 0.81.

Notes:

  • this type requires a sprite to be visible from the map editor.

Sprites:

  • <name><1..> for variant sprites of the floor;
  • <name>-edge optional edge sprite.

OverlayFloor

Extends Floor

For example:

  • tendrils

DoubleOverlayFloor

Extends OverlayFloor

For example:

  • pebbles

OreBlock

Extends OverlayFloor

field default
variants 3

Rock

Extends Block

field type
variants int

Defaults:

field default
breakable true
alwaysReplace true

StaticWall

Extends Rock

Defaults:

field default
breakable false
alwaysReplace false
solid true
variants 2

Sprites:

  • <name>-large.png which is a 2x2 variant of the block.

StaticTree

Extends StaticWall

For example:

  • spore-pine
  • snow-pine
  • pine
  • shrubs

TreeBlock

Extends Block

Defaults:

field default
solid true
layer power
expanded true

Crafting

GenericCrafter

Extends Block

field type default notes
outputItem ItemStack   one item stack
outputLiquid LiquidStack   one liquid stack
craftTime float 80  
craftEffect Effect none  
updateEffect Effect none  
updateEffectChance float 0.04  

Defaults:

field default
update true
solid true
hasItems true
health 60
idleSound machine
idleSoundVolume 0.03
sync true

GenericSmelter

Extends GenericCrafter

A GenericCrafter with a new glowing region drawn on top.

field type default
flameColor Color ffc999

Sprite suffix:

  • <name>-top

Separator

Extends Block

Separator takes liquid as an input, and will produce items from it's stack randomly, using the amount of items in the stack as probability. Separator can't accept items as input, as it will output all the items you put in it, regardless of what you put in results.

field type default notes
results [ ItemStack ]   [required]
craftTime float    
spinnerSpeed float 3  
color Color 858585  

Defaults:

field default
update true
solid true
hasItems true
hasLiquids true

Sprite suffixes:

  • <name>-liquid
  • <name>-spinner

Sandbox

PowerVoid

Extends PowerBlock

Deafults:

field default
consumesPower

PowerSource

Extends PowerNode

Defaults:

field default
maxNodes 100
outputsPower true
consumesPower false

ItemSource

Extends Block

Defaults:

field default
hasItems true
update true
solid true
group transportation
configurable true

ItemVoid

Extends Block

Defaults:

field default
update true
solid true

LiquidSource

Extends Block

Defaults:

field default
hasLiquids true
update true
solid true
liquidCapacity 100
configurable true
outputsLiquid true

LiquidVoid

Extends Block

Defaults:

field default
hasLiquids true
solid true
update true

Logic

MessageBlock

Extends Block

field type default
maxTextLength int 220
maxNewlines int 24

Defaults:

field default
solid true
configurable true
destructible true

Defense

Wall

Extends Block

field type default
variants int 0

Defaults:

field default
solid true
destructible true
group walls
buildCostMultiplier 5

DeflectorWall

Extends Wall – Wall that deflects low damage bullets.

field type default
hitTime float 10
maxDamageDeflect float 10

SurgeWall

Extends Wall – Wall that creates lightning when shot.

field type default
lightningChance float 0.05
lightningDamage float 15
lightningLength int 17

Door

Extends Wall

field type default
openfx Effect dooropen
closefx Effect doorclose

Defaults:

field default
solid false
solidfies true
consumesTap true

Sprites:

  • <name>-open

MendProjector

Extends Block

field type default
color Color 84f491
phase Color ffd59e
reload float 250
range float 60
healPercent float 12
phaseBoost float 12
phaseRangeBoost float 50
useTime float 400

Sprites:

  • <name>-top

OverdriveProjector

Extends Block

field type default
color Color feb380
phase Color ffd59e
reload float 60
range float 80
speedBoost float 1.5
speedBoostPhase float 0.75
useTime float 400
phaseRangeBoost float 20

Defaults:

field default
solid true
update true
hasPower true
hasItems true
canOverdrive false

Sprites:

  • <name>-top

ForceProjector

Extends Block

field type default
phaseUseTime float 350
phaseRadiusBoost float 80
radius float 101.7
breakage float 550
cooldownNormal float 1.75
cooldownLiquid float 1.5
cooldownBrokenBase float 0.35
basePowerDraw float 0.2

Defaults:

field default
update true
solid true
hasPower true
canOverdrive false
hasLiquids true
hasItems true
consumes cold-liquid

Sprites:

  • <name>-top

cold-liquid

  • temperature less then 0.5
  • flammability less then 0.1
  • booster true
  • optional true
  • update false

ShockMine

Extends Block

field type default
cooldown float 80
tileDamage float 5
damage float 13
length int 10
tendrils int 6

Defaults:

field default
update false
destructible true
solid false
targetable false
layer overlay
rebuildable false

Turrets

This section is for turret types. All turrets shoot BulletType, and this means LiquidTurret can shoot MissileBulletType and ItemTurret can shoot LiquidBulletType.

Turret

Abstract type which extends Block

The purpose of a turret type is to be a Block that shoots bullets. Turret is the base type for all turrets, it's abstract meaning it shouldn't be used directly, but everything which extends it will get it's fields.

field type default notes
heatColor Color turretHeat The color of the -heat sprite.
shootEffect Effect none An effect fired on tile in the direction the turret is aiming when it shoots.
smokeEffect Effect none An effect fired on tile in the direction the turret is aiming when it shoots.
ammoUseEffect Effect none An effect fired on the tile, when ammo is consumed.
shootSound Sound shoot A sound created from the tile when a bullet is fired.
ammoPerShot int 1 The amount of ammo used per shot.
ammoEjectBack float 1 The eject angle of shells in radians.
range float 50 The range at which the turret can target enemies. Range is in tilesize so 8 is 1 tile.
reload float 10 The amount of ticks it takes to reload.
inaccuracy float 0 The degrees of inaccuracy.
shots int 1 The numbers of bullets fired at once.
spread float 4 The angular spread of multiple bullets when shot.
recoil float 1 The recoil of the turret when fired.
restitution float 0.02 The restitution from recoil after shooting. (time taken to recenter)
cooldown float 0.02 The amount of time it takes for the -heat sprite to become transparent.
rotatespeed float 5 The degrees per tick at which the turret can rotate.
shootCone float 8 The angle used to determine whether the turret should be shooting.
shootShake float 0 The amount of camera shake.
xRand float 0 The random x axis multiplier, to make bullets appear to come out of multiple places. Used in Swarmer for example.
targetAir boolean true Whether this target can target air units.
targetGround boolean true Whether this turret can target ground units or blocks.

Defaults:

field default
priority turret
update true
solid true
layer turret
group turrets
outlineIcon true

Sprites:

  • <name> the turret sprite,
  • <name>-heat the heat map.

Sprites-Override:

  • block-<1..> global turret base override, where the number is the turrets size. Can be used to override existing turret bases, as well as adding larger ones.

CooledTurret

Extends Turret – This is a base type that turrets which use Liquid to cool themselves extend from.

field type default notes
coolantMultiplier float 5 How much reload is lowered by for each unit of liquid of heat capacity.
coolEffect Effect shoot  

Notes:

  • doesn't take flammable fluid
  • doesn't take hot fluid

ItemTurret

Extends CooledTurret

This type is a turret that uses items as ammo. The key to the ammo field should be the name of an Item, while the value may be any Built-in Bullets or a BulletType itself.

type: ItemTurret
ammo: {
  copper: standardCopper

  metaglass: {
    type: MissileBulletType
    damage: 2
  }

  surge-alloy: {
    type: LiquidBulletType
    damage: 3
  }
}

Here we're using copper to shoot standardCopper (built-in bullet) and metalglass to shoot a custom bullet of type MissileBulletType.

field type default notes
maxAmmo int 30  
ammo { String: BulletType }   String is the name of an Item, which will be used to select the type of bullet which will be shot.

Defaults:

field default
hasItems true

LiquidTurret

Extends Turret

This type is just a turret that uses liquid as ammo. The key to ammo must be the name of a Liquid, while the value may either be the name of any Built-in Bullets or a BulletType itself.

For example you could do something like this:

type: LiquidTurret
ammo: {
  water: {
    type: MissileBulletType
    damage: 9000
  }

  slag: {
    type: LiquidBulletType
    damage: 0
  }
}
fields type notes
ammo { String: BulletType } object with Liquid names to bullet types.

Defaults:

fields default
hasLiquids true
activeSound spray

DoubleTurret

Extends ItemTurret

ItemTurret that shoots from two side-by-side barrels.

field type default
shotWidth float 2

Default:

field default
shots 2

ArtilleryTurret

Extends ItemTurret – Artillery turrets have special shooting calculations done to hit targets.

field default
targetAir false

BurstTurret

Extends ItemTurret – Turrets capable of bursts of specially spaced bullets, separated by long reload times.

field type default
burstSpacing float 5

PowerTurret

Extends CooledTurret – Turret which uses power has ammo to shoot.

field type default notes
shootType BulletType   [required]
powerUse float 1  

Defaults:

field default
hasPower true

ChargeTurret

Extends PowerTurret

field type default
chargeTime float 30
chargeEffects int 5
chargeMaxDelay float 10
chargeEffect Effect none
chargeBeginEffect Effect none

LaserTurret

Extends PowerTurret

field type default notes
firingMoveFract float 0.25 rotatespeed fraction when turret is shooting
shootDuration float 100  

Defaults:

field default
canOverdrive false
coolantMultiplier 1

Doesn't update shoot if:

  • liquid temperature greater or equal to 0.5
  • liquid flammability greater then 0.1

Distribution

Conveyor

Extends Block

field type default
speed float 0

Default:

field default
rotate true
update true
layer overlay
group transportation
hasItems true
itemCapacity 4
idleSound conveyor
idleSoundVolume 0.004
unloadable false

Sprite suffix:

ArmoredConveyor

Extends Conveyor -A type of conveyor don't accept item coming from side

Router

Extends Block

Defaults:

field default
solid true
update true
hasItems true
itemCapacity 1
group transportation
uploadable false

Junction

Extends Block

field type default notes
speed float 26 frames taken to go through this junction
capacity capacity 6  

Defaults:

field default
update true
solid true
group transportation
unloadable false

ItemBridge

Extends Block

field type default
range int  
transportTime float 2

Defaults:

field default
update true
solid true
hasPower true
layer power
expanded true
itemCapacity 10
posConfig true
configurable true
hasItems true
unloadable false
group transportation

Sprites:

ExtendingItemBridge

Extends ItemBridge

Defaults:

field default
hasItems true

BufferedItemBridge

Extends ExtendingItemBridge

field type default
speed float 40
bufferCapacity int 50

Defaults:

field default
hasItems true
hasPower false

Sorter

Extends Block

field type default notes
invert boolean   [optional]

Defaults:

field default
update true
solid true
instantTransfer true
group transportation
configurable true
unloadable false

OverflowGate

Extends Block

Type used for overflow and underflow gates.

field type default notes
speed float 1 delta time multiplier for whether an item can be moved after an update cycle
invert boolean false true makes it underflow

Defaults:

field default
hasItems true
solid true
update true
group transportation
unloadable false

MassDriver

Extends Block – Uses driverBolt to transfer items.

field type default
range float  
rotateSpeed float 0.04
translation float 7
minDistribute int 10
knockback float 4
reloadTime float 100
shootEffect Effect shootBig2
smokeEffect Effect shootBigSmoke2
recieveEffect Effect mineBig
shake float 3

Notes:

  • range is limited by driverBolt's max range, which is hard coded, so you cannot change it.

Defaults:

field default
update true
solid true
posConfig true
configurable true
hasItems true
layer turret
hasPower true
outlineIcon true

Sprites:

  • <name>-base

Liquid Blocks

LiquidBlock

Extends Block – For blocks that can carry liquids. Apart from the better defaults, it also fetches extra sprites.

Defaults:

field default
update true
solid true
hasLiquids true
group liquids
outputsLiquid true

Sprites:

  • <name>-liquid
  • <name>-top
  • <name>-bottom

Pump

Extends LiquidBlock

field type default
pumpAmount float 1
field default
layer overlay
group liquids
floating true

Conduit

Extends LiquidBlock

field type
leakResistance float

Defaults:

field default
rotate true
solid false
floating true

Sprites:

  • <name>-top-<0..6>

ArmoredConduit

Extends Conduit

Defaults:

field default
leakResistance 10

Sprites:

  • <name>-cap

LiquidOverflowGate

Extends LiquidBlock

Defaults:

field default
rotate true

Sprites:

  • <name>-top

LiquidRouter

Extends LiquidBlock

LiquidTank

Extends LiquidRouter

LiquidJunction

Extends LiquidBlock

LiquidBridge

Extends LiquidBridge

field default
hasItems false
hasLiquids true
outputsLiquid true
group liquids

LiquidExtendingBridge

Extends ExtendingItemBridge

field default
hasItems false
hasLiquids true
outputsLiquid true
group liquids

Power

PowerBlock

Abstract type which extends Block

Defaults:

field default
update true
solid true
hasPower true
group power

PowerNode

Extends PowerBlock

field type default
laserRange float 6
maxNodes int 3

Defaults:

field default
expanded true
layer power
configurable true
consumesPower false
outputsPower false

PowerDistributor

Extends PowerBlock

Defaults:

field default
consumesPower false
outputsPower true

Battery

Extends PowerDistributor

field type default
emptyLightColor Color f8c266
fullLightColor Color fb9567

Defauts:

field default
outputsPower true
consumesPower true

Sprites:

  • <name>-top light region on top of the battery.

PowerGenerator

Extends PowerDistributor

Power generators will produce power with their Consumers type.

field type notes
powerProduction float Power produced per tick at 100% (1.0) efficiency; 1 powerProduction is approximately 60 pu/s.

Defaults:

field default
baseExplosiveness 5
sync true

ThermalGenerator

Extends PowerGenerator – Generates power with the attribute of a tile. Power production is powerProduction * attribute, and attribute must be greater then 0.01.

field type default notes
generateEffect Effect none  
attribute Attribute heat The attribute used to vary efficiency.

ItemLiquidGenerator

Extends PowerGenerator – Base of power generation blocks.

Notes:

  • item efficiency is always 0.0
  • liquid efficiency is always 0.0

(this type doesn't produce power)

field type default notes
minItemEfficiency float 0.2  
itemDuration float 70 number of ticks during which a single item will produce power.
minLiquidEfficiency float 0.2  
maxLiquidGenerate float 0.4 Maximum liquid used per frame.
generateEffect Effect generatespark  
explodeEffect Effect generatespark  
heatColor Color ff9b59  
randomlyExplode boolean true  
defaults boolean false  

Extra sprites:

  • <name>-top if hasItems is true
  • <name>-liquid

SingleTypeGenerator

Extends ItemLiquidGenerator – Generates power from an item.

BurnerGenerator

Extends ItemLiquidGenerator – Generates power from item flamability.

DecayGenerator

Extends ItemLiquidGenerator – Generates power from item radioactivity.

Defaults:

field default
hasItems true
hasLiquids false

SolarGenerator

Extends PowerGenerator – A generator that always produces 100% efficiency power.

Notes:

  • Lower targetting priority then other generators.

NuclearReactor

Extends PowerGenerator – Generates power relative to how many items are in storage, and explodes if it runs out of coolant.

field type default notes
lightColor Color 7f19ea  
coolColor Color ffffff00  
hotColor Color ff9575a3  
itemDuration float 120 time to consume 1 fuel
heating float 0.01 heating per frame * fullness
smokeThreshold float 0.3 heat at which blocks start smoking
explosionRadius int 40  
explosionDamage int 1350  
flashThreshold float 0.46 heat at which lights start flashing
coolantPower float 0.5  

Defaults:

field default
itemCapacity 30
liquidCapacity 30
hasItems true
hasLiquids true
rebuildable false

Extra Sprites:

  • <name>-center top region
  • <name>-lights lights region

ImpactReactor

Extends PowerGenerator – Generator that uses power and has a startup time.

field type default notes
plasmas int 4 number of plasma sprites
warmupSpeed float 0.001  
itemDuration float 60  
explosionRadius int 50  
explosionDamage int 2000  
plasma1 Color ffd06b  
plasma2 Color ff361b  

Defaults:

field default
hasPower true
hasLiquids true
liquidCapacity 30
hasItems true
outputsPower true
consumesPower true

Sprites:

  • <name>-bottom bottom region
  • <name>-plasma-<i> plasma regions, where i is 0 to plasmas - 1.

PowerDiode

Extends Block

Defaults:

field default
rotate true
update true
solid true
insulated true

Sprites:

  • <name>-arrow

LightBlock

Extends Block

field type default
brightness float 0.9
radius float 200

Defaults:

field default
hasPower true
update true
configurable true

Sprites:

  • <name>-top

Production

Drill

Extends Block – Types which can be placed on ore blocks to extract the OreBlock's item.

field type default notes
tier int   Maximum tier of blocks this drill can mine.
drillTime float 300 Base time to drill one ore, in frames.
liquidBoostIntensity float 1.6 How many times faster the drill will progress when boosted by liquid.
warmupSpeed float 0.02 Speed at which the drill speeds up.
drawMineItem boolean false Whether to draw the item this drill is mining.
drillEffect Effect mine Effect played when an item is produced. This is colored.
rotateSpeed float 2 Speed the drill bit rotates at.
updateEffect Effect pulverizeSmall Effect randomly played while drilling.
updateEffectChance float 0.02 Chance the update effect will appear.
drawRim boolean false  
heatColor Color ff5512  

Defaults:

field default
update true
solid true
layer overlay
group drills
hasLiquids true
liquidCapacity 5
hasItems true
idleSound drill
idleSoundVolume 0.003

Sprites:

  • <name>-rim
  • <name>-rotator
  • <name>-top

SolidPump

Extends Pump – Pump that makes liquid from solids and takes in power. Only works on solid floor blocks.

field type default
result Liquid water
updateEffect Effect none
updateEffectChance float 0.02
rotateSpeed float 1
attribute Attribute  

Defaults:

field default
hasPower true

Sprites:

  • <name>-liquid

Cultivator

Extends GenericCrafter

field type default
recurrence float 6

Defaults:

field default
craftEffect none

Sprites:

  • <name>-middle
  • <name>-top

Fracker

Extends SolidPump

field default
itemUseTime 100

Defaults:

field default
hasItems true

Sprites:

  • <name>-liquid
  • <name>-rotater
  • <name>-top

Incinerator

Extends Block

field type default
effect Effect fuelburn
flameColor Color ffad9d

Defaults:

field default
hasPower true
hasLiquid true
update true
solid true

Unit Blocks

RepairPoint

Extends Block – Block which can repair units within range, with a laser.

field type default
repairRadius float 50
repairSpeed float 0.3
powerUse float  

Defaults:

field default
update true
solid true
hasPower true
outlineIcon true
layer turret
layer2 power

Extra sprites:

  • <name>-base

UnitFactory

Extends block – A block can produce units

field type default
produceTime float 1000
launchVelocity float 0
maxSpawn int 4
unitType UnitType none

Defaults:

field default
update true
hasPower true
hasItems true
solid false
flags producer

Sprite suffix:

  • -top

CommandCenter

Extends Block – A block which can issue commands to your unit.

field type default
topColor Color command
bottomColor Color 5e5e5e
effect Effect commandSend

Defaults:

field default
flags comandCenter
destructible true
solid true
configurable true

MechPad

Extends Block – A block which will spawn a player in a mech.

field type default
mech Mech none
buildTime float 60 * 5

Defaults:

field default
update true
solid true
hasPower true
layer overlay
flags mechpad

Storage

StorageBlock

Abstract type which extends Block

Defaults:

field default
hasItems true

CoreBlock

Extends StorageBlock

field type default
mech Mech starter

Defaults:

field default
solid true
update true
hasItems true
activeSound respawning
activeSoundVolume 1
layer overlay

Vault

Extends StorageBlock

Defaults:

field default
solid true
destructible true
update false

Unloader

Extends Block

A block which can take items from StorageBlock, like Vault, CoreBlock or Crafters.

field type default
speed float 1

Defaults:

field default
solid true
health 70
update false
hasItems true
confugurable true

Sprites:

  • <name>-center

LaunchPad

Extends StroageBlock

A block which can launch materials.

field type default
launchTime float none

Defaults:

field default
update true
hasItems true
solid true

Attributes

An object with an array of attribute. Used in the Floor type to give a tile specific properties, like hottness or sporness for efficiency of various systems, like ThermalPumps and WaterExtractors.

array has 4 items:

  • index 0 is heat,
  • index 1 is spores,
  • index 2 is water,
  • index 3 is oil.

    For example, this would give you 100 heat, 1 spores, 0.5 water and 0.1 oil.

    {
        "array": [ 100, 1, 0.5, 0.1]
    }
    

    You could use it inside of Floor type as such:

    {
        "type": "Floor",
        "name": "magma",
        "attributes": { "array": [ 0.75, 0, 0, 0 ] }
    }
    

Attribute

New attributes cannot be added. List of built-in attributes:

  • heat
  • spores
  • water
  • oil

BuildVisibility

A flag used by the game to change a few special-case things. It may be one of the following strings:

  • hidden
  • shown
  • debugOnly
  • sandboxOnly
  • campaignOnly
  • lightingOnly

BlockGroup

Groups for blocks to build on top of each other:

  • none
  • walls
  • turrets
  • transportation
  • power
  • liquids
  • drills

Type

Item

Extends Content – It's the object that can ride conveyors, sorters and be stored in containers, and is commonly used in crafters.

field type default notes
color Color black hex string of color
type ItemType resource used for tabs and core acceptance
explosiveness float 0 how explosive this item is.
flammability float 0 flammability above 0.3 makes this eleigible for item burners.
radioactivity float   how radioactive this item is. 0=none, 1=chernobyl ground zero
hardness int 0 drill hardness of the item
cost float 1 used for calculating place times; 1 cost = 1 tick added to build time
alwaysUnlocked boolean false If true, item is always unlocked.

ItemType

  • resource can't go in the core;
  • material can go in the core.

ItemStack

A ItemStack can be a string or an object. It's used to describe the type and amount of items to a machine.

As a string:

copper/5

As an object:

item: copper
amount: 5
field type notes
item string The name of an Item.
amount int The amount of said item.

Liquid

Extends Content

Type which defines the properties of a liquid. Like Item this will go into it's own subdirectory content/liquids/liquid-name.json, and from it's stem name you can reuse it from your other mod content.

field type default notes
color Color   [required] color of liquid
barColor Color   [optional] color used in bars.
lightColor Color   Color used to draw lights. Note that the alpha channel is used to dictate brightness.
flammability float   0 to 1; 0 is completely inflammable, above that may catch fire when exposed to heat.
temperature float 0.5 0.5 is 'room' temperature, 0 is very cold, 1 is molten hot
heatCapacity float 0.5 used in cooling; water is 0.4, cryofluid is 0.9.
viscosity float 0.5 how thick this liquid is; water is 0.5, oil is 0.7.
explosiveness float   explosiveness when heated; 0 is nothing, 1 is nuke
effect StatusEffect none the associated status effect.

Sprites:

  • <name>, the sprite used when displaying the liquid from a menu.

LiquidStack

A LiquidStack can be a string or an object. It's used to describe the type and amount of liquid to a machine.

As a string:

water/0.5

As an object:

liquid: water
amount: 0.5
field type notes
liquid string The name of a Liquid.
amount float The amount of said liquid.

Weapon

Weapons are used by units and mechs alike. A weapon is a type used to shoot bullets bullets just like turrets (except that they don't have an ammo mapping). Weapons can only shoot one type of bullet, which you define in the bullet field.

field type default notes
name String   used to fetch the sprite of the weapon
nimPlayerDist float 20 minimum cursor distance from player, fixes 'cross-eyed' shooting.
sequenceNum int 0  
bullet BulletType   bullet shot
ejectEffect Effect none shell ejection effect
reload float   weapon reload in frames
shots int 1 amount of shots per fire
spacing float 12 spacing in degrees between multiple shots, if applicable
inaccuracy float 0 inaccuracy of degrees of each shot
shake float 0 intensity and duration of each shot's screen shake
recoil float 1.5 visual weapon knockback.
length float 3 shoot barrel y offset
width float 4 shoot barrel x offset.
velocityRnd float 0 fraction of velocity that is random
alternate bool false shoot one arm after another, rather than all at once
lengthRand float 0 randomization of shot length
shotDelay float 0 delay in ticks between shots
ignoreRotation boolean false whether shooter rotation is ignored when shooting.
targetDistance float 1 if turnCursor is false for a mech, how far away will the weapon target.
shootSound Sound pew  

Sprite:

  • <name> or <name>-equip

UnitType

Extends Content

field type default
type BaseUnit  
health float 60
hitsize float 7
hitsizeTile float 4
speed float 0.4
range float 0
attackLength float 150
rotatespeed float 0.2
baseRotateSpeed float 0.1
shootCone float 15
mass float 1
flying boolean  
targetAir boolean true
rotateWeapon boolean false
drag float 0.1
maxVelocity float 5
retreatPercent float 0.6
itemCapacity int 30
buildPower float 0.3
minePower float 0.7
weapon Weapon  
weaponOffsetY float  
engineOffset float  
engineSize float  

Sprites:

  • <name>
  • <name>-leg
  • <name>-base

Mech

Extends Content

Mechs are the player controlled entities. They shoot bullets just like turrets from their weapon.

field type default notes
flying boolean    
speed float 1.1  
maxSpeed float 10  
boostSpeed float 0.75  
drag float 0.4  
mass float 1  
shake float 0  
health float 200  
hitsize float 6  
cellTrnsY float 0  
mineSpeed float 1  
drillPower int -1  
buildPower float 1  
engineColor Color boostTo  
itemCapacity int 30  
turnCursor boolean true  
canHeal boolean false  
compoundSpeed float 5  
compoundSpeedBoost float 5  
drawCell boolean true draw the health and team indicator
drawItems boolean true draw the items on its back
drawLight boolean true draw the engine light if it's flying/boosting
weaponOffsetY float 5  
engineOffset float 5  
engineSize float 2.5  
weapon Weapon null  

Sprites:

  • <name>
  • <name>-leg
  • <name>-base

Category

Categories for building menu:

  • turret Offensive turrets;
  • production Blocks that produce raw resources, such as drills;
  • distribution Blocks that move items around;
  • liquid Blocks that move liquids around;
  • power Blocks that generate or transport power;
  • defense Walls and other defensive structures;
  • crafting Blocks that craft things;
  • units Blocks that create units;
  • upgrade Things that upgrade the player such as mech pads;
  • effect Things for storage or passive effects.

Zone

Extends Content

A Zone is a type that takes a map (named the same as the json's filename) and puts it into campaign. (a zone isn't a map)

Every Zone has a Generator, which once initialized, MapGenerator will run through the map and do initialization related stuff. One of those notable things, is deleting all cores on in your map and placing a loadout on top of a random one of them. This allows your campaign map to have multiple core locations. (it doesn't matter which core was previously on the map, loadout will dictate that)

It is entirely possible to produce a custom schematic, but take note that this schematic must contain a CoreBlock within it.

field type default notes
baseLaunchCost [ ItemStack ]    
launchCost [ ItemStack ]    
startingItems [ ItemStack ]   Items you start with on the map.
conditionWave int  
alwaysUnlocked boolean false Whether this map is always unlocked
launchPeriod int 10 Rate of waves at which the core may be launched.
loadout Schematic basicShard Core layout placed by MapGenerators.
resources [ String ]   Array of item names.
requirements [ Objective ]   An array of requirements to unlock configuration.
configureObjective Objective ZoneWave 15  
defaultStartingItems [ ItemStack ]    

Sprites:

  • zone-<name> preview
  • <name>-zone preview

Built-in loadouts:

  • basicShard

    bXNjaAB4nD2K2wqAIBiD5ymibnoRn6YnEP1BwUMoBL19FuJ2sbFvUFgYZDaJsLeQrkinN9UJHImsNzlYE7WrIUastuSbnlKx2VJJt+8IQGGKdfO/8J5yrGJSMegLg+YUIA==
    

    img

  • advancedShard

    bXNjaAB4nD2LjQqAIAyET7OMIOhFfJqeYMxBgSkYCL199gu33fFtB4tOwUTaBCP5QpHFzwtl32DahBeKK1NwPq8hoOcUixwpY+CUxe3XIwBbB/pa6tadVCUP02hgHvp5vZq/0b7pBHPYFOQ=
    

    img

  • basicFoundation

    bXNjaAB4nD1OSQ6DMBBzFhVu8BG+0X8MQyoiJTNSukj8nlCi2Adbtg/GA4OBF8oB00rvyE/9ykafqOIw58A7SWRKy1ZiShhZ5RcOLZhYS1hefQ1gRIeptH9jq/qW2lvc1d2tgWsOfVX/tOwE86AYBA==
    

    img

  • basicNucleus

    bXNjaAB4nD2MUQqAIBBEJy0s6qOLdJXuYNtCgikYBd2+LNmdj308hkGHtkId7M4YFns4mk/yfB4a48602eDI+mlNznu0FMPFd0wYKCaewl8F0EOueqM+yKSLVfJrNKWnSw/FZGzEGXFG9sy/px4gEBW1
    

    img

Built-in zones:

  • nuclearComplexe
  • desolateRift
  • tarFields
  • overgrowth
  • stainedMountains
  • frozenForest
  • saltFlats
  • desertWastes
  • groundZero

StatusEffect

Extends Content

Not be be confused with Effect, a status effect will give an entity special properties. Status effects are used as transitions between intermediate effects. If some a wet unit gets shocked it then gets 20 damage.

field type default notes
damageMultiplier float 1  
armorMultiplier float 1  
speedMultiplier float 1  
color Color white  
damage float   Damage (or healing) per frame.
effect Effect none Random effect (0.15% per frame), on affected units.
  • opposites: effect which reduces anothers lifetime.

Built-in status effects:

  • none – Does nothing.

  • burning

    field value
    damage 0.06
    effect burning
    • opposites: wet freezing
    • tarred: 1 damage and keeps burning
  • freezing

    field value
    speedMultiplier 0.6
    armorMultiplier 0.8
    effect freezing
    • opposites: melting burning
  • wet

    field value
    speedMultiplier 0.9
    effect wet
    • opposites: burning
    • shocked: 20 damage
  • melting

    field value
    speedMultiplier 0.8
    armorMultiplier 0.8
    damage 0.3
    effect melting
    • opposites: wet freezing
    • tarred: keeps melting
  • tarred

    field value
    speedMultiplier 0.6
    effect oily
    • burning: keeps burning
    • melting: keeps burning
  • overdrive

    field value
    armorMultiplier 0.95
    speedMultiplier 1.15
    damageMultiplier 1.4
    damage -0.01
    effect overdriven
  • shielded

    field value
    armorMultiplier 3
  • boss

    field value
    armorMultiplier 3
    damageMultiplier 3
    speedMultiplier 1.1
  • shocked – Does nothing.

  • corroded

    field value
    damage 0.1

Graphics

Layer

Layers is an enumeration type, which the renderer will use to group rendering order:

  • block, base block layer;
  • placement, for placement;
  • overlay, first overlay stuff like conveyor items;
  • turret, "high" blocks like turrets;
  • power power lasers

Color

Color is a hexadecimal string, <rr><gg><bb> for example:

  • ff0000 is red,
  • 00ff00 is green,
  • 0000ff is blue,
  • ffff00 is yellow,
  • 00ffff is cyan,
  • ect..

CacheLayer

Flags used by for cache render:

  • normal normal layer;
  • walls walls layer;
  • water water layer, adding tile water shaders, and giving wave reflections;
  • tar tar layer, adding tar shaders, making it darker and giving it some bubble reflections;

Entities

BulletType

Abstract type which extends Content

BulletType can either be an object {} or a "string", where a string would be reusing Built-in Bullets and an object would be making a custom one.

There are two major categories of bullet types:

Here's an example of a custom bullet:

{
    "type": "MissileBulletType",
    "lifetime": 1000,
    "speed": 2,
    "splashDamageRadius": 2,
    "splashDamage": 9,
    "frontColor": "ffff00",
    "backColor": "00ffff",
    "homingPower": 1,
    "homingRange": 20,
    "fragBullets": 3,
    "fragBullet": {
        "type": "LiquidBulletType",
        "liquid": "oil",
        "lifetime": 2,
        "speed": 1,
        "fragBullets": 2,
        "fragBullet": {
            "type": "LiquidBulletType",
            "liquid": "slag",
            "lifetime": 1,
            "speed": 2,
            "damage": 1,
        }
    }
}

img

field type default notes
lifetime float   amount of ticks the bullet will last
speed float   inital speed of bullet
damage float   collision damage
hitSize float 4 collision radius
drawSize float 40  
drag float 0 decelleration per tick
pierce boolean   whether it can collide
hitEffect Effect   created when bullet hits something
despawnEffect Effect   created when bullet despawns
shootEffect Effect   created when shooting
smokeEffect Effect   created when shooting
hitSound Sound   made when hitting something or getting removed
inaccuracy float 0 extra inaccuracy
ammoMultiplier float 2 how many bullets get created per item/liquid
reloadMultiplier float 1 multiplied by turret reload speed
recoil float   recoil from shooter entities
killShooter float   whether to kill the shooter when this is shot. (for suicide bombers)
knockback float   Knockback in velocity.
hitTiles boolean true Whether this bullet hits tiles.
status StatusEffect none Status effect applied on hit.
statusDuration float 600 Intensity of applied status effect in terms of duration.
collidesTiles boolean true Whether this bullet type collides with tiles.
collidesTeam boolean false Whether this bullet type collides with tiles that are of the same team.
collidesAir boolean true Whether this bullet type collides with air units.
collides boolean true Whether this bullet types collides with anything at all.
keepVelocity boolean true Whether velocity is inherited from the shooter.
fragBullets int 9 Number of frag bullets created.
fragVelocityMin float 0.2 Minimum random multiplier.
fragVelocityMax float 1 Maximum random multiplier.
fragBullet BulletType null The frag bullet that will be created, may be a string, an object or null. If field is null, no frag bullet is created.
instantDisappear boolean   Whether to instantly make the bullet disappear. (used in crawlers to make sure they explode)
splashDamage float 0 Area of effect damage when the bullet despawns or hits a target. Damage is calculated with linear interpolation, also known as lerp.
splashDamageRadius float -1 Use a negative value to disable splash damage. splashDamageRadius is a value used in the equation lerp(1 - distance / radius, 1, 0.4) which is a multiplier for splashDamage.
incendAmount int 0  
incendSpread float 8  
incendChance float 1  
homingPower float 0 Doesn't do anything complicated; if homingPower larger then 0.01 it gets rendered in the UI, if homingPower is larger then 0.0001 it allows homingRange to work.
homingRange float 50 How close the bullet needs from a target in order to home/seek said target.
lightining int    
lightningLength int 5  
hitShake float 0  

BasicBulletType

Extends BulletType

This types purpose is to give basic bullets their sprites. The bulletSprite will be used as the shape of the bullet. The visible pixels in your sprites will be tinted with backColor and frontColor respectively. For example if you had sprites router.png and router-back.png where Test Mod was your mods name, you could do this to include your bulletSprite:

{
    "type": "BasicBulletType",
    "bulletSprite": "test-mod-router"
}

img

field type default  
bulletWidth float 5  
bulletHeight float 7  
bulletShrink float 0.5 Used to squishify the bullet as it gets closer to the target, where 0 is no shrink -0.5 is stretching and 0.5 is shrinking.
frontColor Color bulletYellow Color of front sprite.
backColor Color bulletYellowBack Color of back sprite.
bulletSprite String bullet Mapping sprite used to make the shape of the bullet.

Sprites:

  • <mod-name>-<sprite-name> top layer bulletSprite
  • <mod-name>-<sprite-name>-back bottom layer bulletSprite

Built-in bulletSprites:

ArtilleryBulletType

Extends BasicBulletType

Makes special calculations to give the effect that the bullet is going up and back down.

field type default
trailEffect Effect artilleryTrail

Defaults:

field default
collidesTiles false
collides false
collidesAir false
hitShake 1
hitSound explosion
bulletSprite shell

FlakBulletType

Extends BasicBulletType

field type default notes
explodeRange float 30 The range at which the bullets explode from enemies.

Defaults:

field type
splashDamage 15
splashDamageRadius 34
hitEffect flakExplosionBig
bulletWidth 8
bulletHeight 10

MissileBulletType

Extends BasicBulletType

Weave is simple a sin wave with the following equation.

rotation = sin(time/scale) * magnitude
field type default notes
trailColor Color missileYellowBack Color of the trail effect.
weaveScale float 0 A larger weaveScale means a longer wave.
weaveMag float -1 A higher weaveMag means a higher (wider) wave.

Defaults:

field default
bulletSprite missile

BombBulletType

Extends BasicBulletType

Defaults:

field default
collidesTiles false
collides false
bulletShrink 0.7
lifetime 30
drag 0.05
keepVelocity false
collidesAir false
hitSound explosion

HealBulletType

Extends BulletType – Bullets that can heal blocks of the same team as the shooter.

field type default
healPercent float 3

Defaults:

field default
shootEffect shootHeal
smokeEffect hitLaser
hitEffect hitLaser
despawnEffect hitLaser
collidesTeam true

LiquidBulletType

Extends BulletType

field type default notes
liquid String null [required] name of Liquid

Defaults:

field default
lifetime 74
statusDuration 90
despawnEffect none
hitEffect hitLiquid
smokeEffect none
shootEffect none
drag 0.009
knockback 0.55

MassDriverBolt

Extends BulletType

Defaults:

field default
collidesTiles false
lifetime 200
despawnEffect smeltsmoke
hitEffect hitBulletBig
drag 0.005

Built-in Bullets

  • artillery:
    • artilleryDense artilleryPlastic artilleryPlasticFrag artilleryHoming artlleryIncendiary artilleryExplosive artilleryUnit
  • flak:
    • flakScrap flakLead flakPlastic flakExplosive flakSurge flakGlass glassFrag
  • missiles:
    • missileExplosive missileIncendiary missileSurge missileJavelin missileSwarm missileRevenant
  • standard:
    • standardCopper standardDense standardThorium standardHoming standardIncendiary standardMechSmall standardGlaive standardDenseBig standardThoriumBig standardIncendiaryBig
  • electric:
    • lancerLaser meltdownLaser lightning arc damageLightning
  • liquid:
    • waterShot cryoShot slagShot oilShot
  • environment & misc:
    • fireball basicFlame pyraFlame driverBolt healBullet healBulletBig frag eruptorShot
  • bombs:
    • bombExplosive bombIncendiary bombOil

BaseUnit

There are a few useful base unit types:

  • FlyingUnit
    • HoverUnit
    • BuilderDrone
    • MinerDrone
    • RepairDrone
  • GroundUnit

Effect

Type should be a string. You can't currently create custom effects. List of built-in effects are as follows:

  • none placeBlock breakBlock smoke spawn tapBlock select
  • vtolHover unitDrop unitPickup unitLand pickup healWave heal landShock reactorsmoke nuclearsmoke nuclearcloud
  • redgeneratespark generatespark fuelburn plasticburn pulverize pulverizeRed pulverizeRedder pulverizeSmall pulverizeMedium
  • producesmoke smeltsmoke formsmoke blastsmoke lava doorclose dooropen dooropenlarge doorcloselarge purify purifyoil purifystone generate
  • mine mineBig mineHuge smelt teleportActivate teleport teleportOut ripple bubble launch
  • healBlock healBlockFull healWaveMend overdriveWave overdriveBlockFull shieldBreak hitBulletSmall hitFuse
  • hitBulletBig hitFlameSmall hitLiquid hitLaser hitLancer hitMeltdown despawn flakExplosion blastExplosion
  • plasticExplosion artilleryTrail incendTrail missileTrail absorb flakExplosionBig plasticExplosionFlak burning fire
  • fireSmoke steam fireballsmoke ballfire freezing melting wet oily overdriven dropItem shockwave
  • bigShockwave nuclearShockwave explosion blockExplosion blockExplosionSmoke shootSmall shootHeal shootSmallSmoke shootBig shootBig2 shootBigSmoke
  • shootBigSmoke2 shootSmallFlame shootPyraFlame shootLiquid shellEjectSmall shellEjectMedium
  • shellEjectBig lancerLaserShoot lancerLaserShootSmoke lancerLaserCharge lancerLaserChargeBegin lightningCharge lightningShoot
  • unitSpawn spawnShockwave magmasmoke impactShockwave impactcloud impactsmoke dynamicExplosion padlaunch commandSend coreLand

TargetPriority

A higher ordinal means a higher priority. Higher priority blocks will always get targeted over those of lower priority, regardless of distance.

  1. base
  2. turret

Objective

Objective is a trait, which a few types implement, which is used by Zone to give campaign maps objectives.

Types which implement Objective are as follows:

  • ZoneWave – complete if best wave within zone is heigher then target wave

    field type notes
    zone String target Zone name
    wave int target wave to reach
  • Launched – complete if core launched from zone

    field type notes
    zone String target Zone name
  • Unlock – complete if block is unlocked

    field type notes
    block String target Block name

Other

Mindustry Source Structure

core/src/io/anuke/mindustry/
├── ai
│   ├── BlockIndexer.java
│   ├── Pathfinder.java
│   └── WaveSpawner.java
├── ClientLauncher.java
├── content
│   ├── Blocks.java
│   ├── Bullets.java
│   ├── Fx.java
│   ├── Items.java
│   ├── Liquids.java
│   ├── Loadouts.java
│   ├── Mechs.java
│   ├── StatusEffects.java
│   ├── TechTree.java
│   ├── TypeIDs.java
│   ├── UnitTypes.java
│   └── Zones.java
├── core
│   ├── ContentLoader.java
│   ├── Control.java
│   ├── FileTree.java
│   ├── GameState.java
│   ├── Logic.java
│   ├── NetClient.java
│   ├── NetServer.java
│   ├── Platform.java
│   ├── Renderer.java
│   ├── UI.java
│   ├── Version.java
│   └── World.java
├── ctype
│   ├── Content.java
│   ├── ContentList.java
│   ├── ContentType.java
│   ├── MappableContent.java
│   └── UnlockableContent.java
├── editor
│   ├── DrawOperation.java
│   ├── EditorTile.java
│   ├── EditorTool.java
│   ├── MapEditorDialog.java
│   ├── MapEditor.java
│   ├── MapGenerateDialog.java
│   ├── MapInfoDialog.java
│   ├── MapLoadDialog.java
│   ├── MapRenderer.java
│   ├── MapResizeDialog.java
│   ├── MapSaveDialog.java
│   ├── MapView.java
│   ├── OperationStack.java
│   └── WaveInfoDialog.java
├── entities
│   ├── bullet
│   │   ├── ArtilleryBulletType.java
│   │   ├── BasicBulletType.java
│   │   ├── BombBulletType.java
│   │   ├── BulletType.java
│   │   ├── FlakBulletType.java
│   │   ├── HealBulletType.java
│   │   ├── LiquidBulletType.java
│   │   ├── MassDriverBolt.java
│   │   └── MissileBulletType.java
│   ├── Damage.java
│   ├── effect
│   │   ├── Decal.java
│   │   ├── Fire.java
│   │   ├── GroundEffectEntity.java
│   │   ├── ItemTransfer.java
│   │   ├── Lightning.java
│   │   ├── Puddle.java
│   │   ├── RubbleDecal.java
│   │   └── ScorchDecal.java
│   ├── Effects.java
│   ├── Entities.java
│   ├── EntityCollisions.java
│   ├── EntityGroup.java
│   ├── Predict.java
│   ├── TargetPriority.java
│   ├── traits
│   │   ├── AbsorbTrait.java
│   │   ├── BelowLiquidTrait.java
│   │   ├── BuilderMinerTrait.java
│   │   ├── BuilderTrait.java
│   │   ├── DamageTrait.java
│   │   ├── DrawTrait.java
│   │   ├── Entity.java
│   │   ├── HealthTrait.java
│   │   ├── KillerTrait.java
│   │   ├── MinerTrait.java
│   │   ├── MoveTrait.java
│   │   ├── Saveable.java
│   │   ├── SaveTrait.java
│   │   ├── ScaleTrait.java
│   │   ├── ShooterTrait.java
│   │   ├── SolidTrait.java
│   │   ├── SpawnerTrait.java
│   │   ├── SyncTrait.java
│   │   ├── TargetTrait.java
│   │   ├── TeamTrait.java
│   │   ├── TimeTrait.java
│   │   ├── TypeTrait.java
│   │   └── VelocityTrait.java
│   ├── type
│   │   ├── base
│   │   │   ├── BaseDrone.java
│   │   │   ├── BuilderDrone.java
│   │   │   ├── FlyingUnit.java
│   │   │   ├── GroundUnit.java
│   │   │   ├── HoverUnit.java
│   │   │   ├── MinerDrone.java
│   │   │   └── RepairDrone.java
│   │   ├── BaseEntity.java
│   │   ├── BaseUnit.java
│   │   ├── Bullet.java
│   │   ├── DestructibleEntity.java
│   │   ├── EffectEntity.java
│   │   ├── Player.java
│   │   ├── SolidEntity.java
│   │   ├── TileEntity.java
│   │   ├── TimedEntity.java
│   │   └── Unit.java
│   ├── units
│   │   ├── StateMachine.java
│   │   ├── Statuses.java
│   │   ├── UnitCommand.java
│   │   ├── UnitDrops.java
│   │   └── UnitState.java
│   └── Units.java
├── game
│   ├── DefaultWaves.java
│   ├── Difficulty.java
│   ├── EventType.java
│   ├── Gamemode.java
│   ├── GlobalData.java
│   ├── LoopControl.java
│   ├── MusicControl.java
│   ├── Objective.java
│   ├── Objectives.java
│   ├── Rules.java
│   ├── Saves.java
│   ├── Schematic.java
│   ├── Schematics.java
│   ├── SoundLoop.java
│   ├── SpawnGroup.java
│   ├── Stats.java
│   ├── Team.java
│   ├── Teams.java
│   └── Tutorial.java
├── graphics
│   ├── BlockRenderer.java
│   ├── Bloom.java
│   ├── CacheLayer.java
│   ├── Drawf.java
│   ├── FloorRenderer.java
│   ├── IndexedRenderer.java
│   ├── Layer.java
│   ├── LightRenderer.java
│   ├── MenuRenderer.java
│   ├── MinimapRenderer.java
│   ├── MultiPacker.java
│   ├── OverlayRenderer.java
│   ├── Pal.java
│   ├── Pixelator.java
│   └── Shaders.java
├── input
│   ├── Binding.java
│   ├── DesktopInput.java
│   ├── InputHandler.java
│   ├── MobileInput.java
│   ├── Placement.java
│   └── PlaceMode.java
├── io
│   ├── JsonIO.java
│   ├── LegacyMapIO.java
│   ├── MapIO.java
│   ├── SaveFileReader.java
│   ├── SaveIO.java
│   ├── SaveMeta.java
│   ├── SavePreviewLoader.java
│   ├── SaveVersion.java
│   ├── TypeIO.java
│   └── versions
│       ├── LegacyTypeTable.java
│       ├── Save1.java
│       ├── Save2.java
│       └── Save3.java
├── maps
│   ├── filters
│   │   ├── BlendFilter.java
│   │   ├── ClearFilter.java
│   │   ├── DistortFilter.java
│   │   ├── FilterOption.java
│   │   ├── GenerateFilter.java
│   │   ├── MedianFilter.java
│   │   ├── MirrorFilter.java
│   │   ├── NoiseFilter.java
│   │   ├── OreFilter.java
│   │   ├── OreMedianFilter.java
│   │   ├── RiverNoiseFilter.java
│   │   ├── ScatterFilter.java
│   │   └── TerrainFilter.java
│   ├── generators
│   │   ├── BasicGenerator.java
│   │   ├── Generator.java
│   │   ├── MapGenerator.java
│   │   └── RandomGenerator.java
│   ├── MapException.java
│   ├── Map.java
│   ├── MapPreviewLoader.java
│   ├── Maps.java
│   └── zonegen
│       ├── DesertWastesGenerator.java
│       └── OvergrowthGenerator.java
├── mod
│   ├── ClassAccess.java
│   ├── ContentParser.java
│   ├── Mod.java
│   ├── ModLoadingSound.java
│   ├── Mods.java
│   └── Scripts.java
├── net
│   ├── Administration.java
│   ├── ArcNetProvider.java
│   ├── CrashSender.java
│   ├── Host.java
│   ├── Interpolator.java
│   ├── NetConnection.java
│   ├── Net.java
│   ├── NetworkIO.java
│   ├── Packet.java
│   ├── Packets.java
│   ├── Registrator.java
│   ├── Streamable.java
│   └── ValidateException.java
├── plugin
│   └── Plugin.java
├── type
│   ├── Category.java
│   ├── ErrorContent.java
│   ├── Item.java
│   ├── ItemStack.java
│   ├── ItemType.java
│   ├── Liquid.java
│   ├── LiquidStack.java
│   ├── Mech.java
│   ├── Publishable.java
│   ├── StatusEffect.java
│   ├── TypeID.java
│   ├── UnitType.java
│   ├── Weapon.java
│   ├── WeatherEvent.java
│   └── Zone.java
├── ui
│   ├── Bar.java
│   ├── BorderImage.java
│   ├── Cicon.java
│   ├── ContentDisplay.java
│   ├── dialogs
│   │   ├── AboutDialog.java
│   │   ├── AdminsDialog.java
│   │   ├── BansDialog.java
│   │   ├── ColorPicker.java
│   │   ├── ContentInfoDialog.java
│   │   ├── ControlsDialog.java
│   │   ├── CustomGameDialog.java
│   │   ├── CustomRulesDialog.java
│   │   ├── DatabaseDialog.java
│   │   ├── DeployDialog.java
│   │   ├── DiscordDialog.java
│   │   ├── FileChooser.java
│   │   ├── FloatingDialog.java
│   │   ├── GameOverDialog.java
│   │   ├── HostDialog.java
│   │   ├── JoinDialog.java
│   │   ├── LanguageDialog.java
│   │   ├── LoadDialog.java
│   │   ├── LoadoutDialog.java
│   │   ├── MapPlayDialog.java
│   │   ├── MapsDialog.java
│   │   ├── MinimapDialog.java
│   │   ├── ModsDialog.java
│   │   ├── PaletteDialog.java
│   │   ├── PausedDialog.java
│   │   ├── SaveDialog.java
│   │   ├── SchematicsDialog.java
│   │   ├── SettingsMenuDialog.java
│   │   ├── TechTreeDialog.java
│   │   ├── TraceDialog.java
│   │   └── ZoneInfoDialog.java
│   ├── Fonts.java
│   ├── fragments
│   │   ├── BlockConfigFragment.java
│   │   ├── BlockInventoryFragment.java
│   │   ├── ChatFragment.java
│   │   ├── FadeInFragment.java
│   │   ├── Fragment.java
│   │   ├── HudFragment.java
│   │   ├── LoadingFragment.java
│   │   ├── MenuFragment.java
│   │   ├── OverlayFragment.java
│   │   ├── PlacementFragment.java
│   │   ├── PlayerListFragment.java
│   │   └── ScriptConsoleFragment.java
│   ├── GridImage.java
│   ├── IconSize.java
│   ├── IntFormat.java
│   ├── ItemDisplay.java
│   ├── ItemImage.java
│   ├── ItemsDisplay.java
│   ├── layout
│   │   ├── BranchTreeLayout.java
│   │   ├── RadialTreeLayout.java
│   │   └── TreeLayout.java
│   ├── Links.java
│   ├── LiquidDisplay.java
│   ├── Minimap.java
│   ├── MobileButton.java
│   ├── MultiReqImage.java
│   ├── ReqImage.java
│   └── Styles.java
├── Vars.java
└── world
    ├── Block.java
    ├── blocks
    │   ├── Attributes.java
    │   ├── Autotiler.java
    │   ├── BlockPart.java
    │   ├── BuildBlock.java
    │   ├── defense
    │   │   ├── DeflectorWall.java
    │   │   ├── Door.java
    │   │   ├── ForceProjector.java
    │   │   ├── MendProjector.java
    │   │   ├── OverdriveProjector.java
    │   │   ├── ShockMine.java
    │   │   ├── SurgeWall.java
    │   │   ├── turrets
    │   │   │   ├── ArtilleryTurret.java
    │   │   │   ├── BurstTurret.java
    │   │   │   ├── ChargeTurret.java
    │   │   │   ├── CooledTurret.java
    │   │   │   ├── DoubleTurret.java
    │   │   │   ├── ItemTurret.java
    │   │   │   ├── LaserTurret.java
    │   │   │   ├── LiquidTurret.java
    │   │   │   ├── PowerTurret.java
    │   │   │   └── Turret.java
    │   │   └── Wall.java
    │   ├── distribution
    │   │   ├── ArmoredConveyor.java
    │   │   ├── BufferedItemBridge.java
    │   │   ├── Conveyor.java
    │   │   ├── ExtendingItemBridge.java
    │   │   ├── ItemBridge.java
    │   │   ├── Junction.java
    │   │   ├── MassDriver.java
    │   │   ├── OverflowGate.java
    │   │   ├── Router.java
    │   │   └── Sorter.java
    │   ├── DoubleOverlayFloor.java
    │   ├── Floor.java
    │   ├── ItemSelection.java
    │   ├── liquid
    │   │   ├── ArmoredConduit.java
    │   │   ├── Conduit.java
    │   │   ├── LiquidBridge.java
    │   │   ├── LiquidExtendingBridge.java
    │   │   ├── LiquidJunction.java
    │   │   ├── LiquidOverflowGate.java
    │   │   ├── LiquidRouter.java
    │   │   └── LiquidTank.java
    │   ├── LiquidBlock.java
    │   ├── logic
    │   │   ├── LogicBlock.java
    │   │   └── MessageBlock.java
    │   ├── OreBlock.java
    │   ├── OverlayFloor.java
    │   ├── power
    │   │   ├── Battery.java
    │   │   ├── BurnerGenerator.java
    │   │   ├── ConditionalConsumePower.java
    │   │   ├── DecayGenerator.java
    │   │   ├── ImpactReactor.java
    │   │   ├── ItemLiquidGenerator.java
    │   │   ├── LightBlock.java
    │   │   ├── NuclearReactor.java
    │   │   ├── PowerDiode.java
    │   │   ├── PowerDistributor.java
    │   │   ├── PowerGenerator.java
    │   │   ├── PowerGraph.java
    │   │   ├── PowerNode.java
    │   │   ├── SingleTypeGenerator.java
    │   │   ├── SolarGenerator.java
    │   │   └── ThermalGenerator.java
    │   ├── PowerBlock.java
    │   ├── production
    │   │   ├── Cultivator.java
    │   │   ├── Drill.java
    │   │   ├── Fracker.java
    │   │   ├── GenericCrafter.java
    │   │   ├── GenericSmelter.java
    │   │   ├── Incinerator.java
    │   │   ├── LiquidConverter.java
    │   │   ├── Pump.java
    │   │   ├── Separator.java
    │   │   └── SolidPump.java
    │   ├── RespawnBlock.java
    │   ├── Rock.java
    │   ├── sandbox
    │   │   ├── ItemSource.java
    │   │   ├── ItemVoid.java
    │   │   ├── LiquidSource.java
    │   │   ├── PowerSource.java
    │   │   └── PowerVoid.java
    │   ├── StaticWall.java
    │   ├── storage
    │   │   ├── CoreBlock.java
    │   │   ├── LaunchPad.java
    │   │   ├── StorageBlock.java
    │   │   ├── Unloader.java
    │   │   └── Vault.java
    │   ├── TreeBlock.java
    │   └── units
    │       ├── CommandCenter.java
    │       ├── MechPad.java
    │       ├── RallyPoint.java
    │       ├── RepairPoint.java
    │       └── UnitFactory.java
    ├── BlockStorage.java
    ├── Build.java
    ├── CachedTile.java
    ├── consumers
    │   ├── ConsumeItemFilter.java
    │   ├── ConsumeItems.java
    │   ├── Consume.java
    │   ├── ConsumeLiquidBase.java
    │   ├── ConsumeLiquidFilter.java
    │   ├── ConsumeLiquid.java
    │   ├── ConsumePower.java
    │   ├── Consumers.java
    │   └── ConsumeType.java
    ├── DirectionalItemBuffer.java
    ├── Edges.java
    ├── ItemBuffer.java
    ├── LegacyColorMapper.java
    ├── meta
    │   ├── Attribute.java
    │   ├── BlockBars.java
    │   ├── BlockFlag.java
    │   ├── BlockGroup.java
    │   ├── BlockStat.java
    │   ├── BlockStats.java
    │   ├── BuildVisibility.java
    │   ├── PowerType.java
    │   ├── Producers.java
    │   ├── StatCategory.java
    │   ├── StatUnit.java
    │   ├── StatValue.java
    │   └── values
    │       ├── AmmoListValue.java
    │       ├── BooleanValue.java
    │       ├── BoosterListValue.java
    │       ├── ItemFilterValue.java
    │       ├── ItemListValue.java
    │       ├── LiquidFilterValue.java
    │       ├── LiquidValue.java
    │       ├── NumberValue.java
    │       └── StringValue.java
    ├── modules
    │   ├── BlockModule.java
    │   ├── ConsumeModule.java
    │   ├── ItemModule.java
    │   ├── LiquidModule.java
    │   └── PowerModule.java
    ├── Pos.java
    ├── producers
    │   ├── ProduceItem.java
    │   └── Produce.java
    ├── StaticTree.java
    ├── Tile.java
    └── WorldContext.java