Modding Documentation

Introduction

The following things can currently be modded:

Game Balance Parameters
Enemies
Weapons
Player Ships
Equipment: Modules, Trainings, Doctrines, etc.
Manual Entries
Zones: Stelas, Hailstorms, etc.
Difficulty Levels
World Maps

To create basic mods, all you need is a plain text editor such as Notepad, but the following software is useful for more complex modding:

A programmer's text editor with syntax highlighting, such as Notepad++
Inkscape to create vector graphics that match the game's style
A sound editor such as Audacity

Mods are folders containing JSON files with game data, images and sounds, text files with translations, a logo image, and an info file describing the mod.

Mods can either be installed via Steam, or installed locally. To install local mods into the game, put them into the "Mods" folder in the game data folder, which is at %APPDATA%\AirshipsLostFlotilla on Windows and at ~/.airshipslostflotilla on Linux. There is also a button in the mods screen that opens that folder.

Here's a number of example mods for you to look at. You may prefer to simply install them and change things around, and learn like that. Look at the files in the Data folder in the game install folder. You can see errors from installed mods in the modlog.txt file in your Mods folder. If the mod outright crashes the game, it may instead create a crash-x.txt file in the game data folder.

Admiral Mubarak: Adds a new captain
Crossbow: Adds a new weapon
Dreadnought: Adds a new player ship by modifying an existing one
Scavenging Crews: Adds a new training that links two stats together
Green Dragon: Adds and integrates a new enemy with its own manual page

Publishing to Steam Workshop

Once you've created your mod locally, you can select it in the mods screen of the game and press the "Upload to Steam" button to put it onto the Steam Workshop. This process adds a workshopID.txt file to your mod folder so the game knows where it is on the workshop. Once the mod is on the workshop, you can press "Update on Steam" to publish any changes.

If you're not using Steam, you can also just distribute your mods by uploading them somewhere.

Mod Structure

The bare minimum mod that does nothing is just a folder with an info.json file. JSON is a text-based data format. It has two data structures: lists (e.g. [1, 2, 3]) and objects with keys and values (e.g. {"cat": 3, "fish": 7}).

info.json files have the following structure:

{
    "id": "example-dreadnought",
    "name": { "eng": "Dreadnought" },
    "description": { "eng": "Example mod adding a modified battleship. "},
    "tags": ["playership"]
}

id: Each mod has an ID string (a string is a piece of text) that should be unique. Two mods with the same ID are considered the same mod, so it's a good idea to give it a name like "shivering-steves-additional-enemies". The ID doesn't show up anywhere in the interface.
name and description: The name and short description of the mod in various languages. The keys are ISO3 language codes such as "eng", "deu", or "chn".
tags: A list of tags for the Steam workshop.

The logo image should be a 636x358px PNG file called logo.png. It's used both in-game in the mods list and as Steam Workshop title image.

Adding, Overriding, and Removing Content

Apart from info.json and logo.png, a mod contains JSON files with the same name and structure as game's Data folder.

The following files can be modded:

DifficultyLevel.json: Difficulty level settings
EntityType.json: Player ships, escorts, enemies, shots
EquipmentType.json: Modules, equipments, trainings, etc.
LandscapeType.json: Background images and what zones appear
LevelType.json: Enemy wave types
ManualPage.json: Manual pages that aren't about enemies
MapNodeType.json: Map locations with specific levels, rewards, etc.
MapType.json: World map layouts
Parameters.json: Game balance parameters
ParticleType.json: Particles used by ships and weapons
WeaponType.json: Weapons for players and enemies
WreckageType.json: Different types of wreckage like crates and honey and scales
ZoneType.json: Local zones like stelas and sandstorms
Parameters.json: Game balance parameters

The following data files can currently not be modded: Abbreviations.json Music.json

The files contain lists of objects describing items, each of which has a name. If you specify an item with the same name as an existing one, it's overwritten. Mods can overwrite items from mods earlier in the load order.

So if you want to e.g. add a new weapon, create a WeaponType.json file in your mod. Here's a small example file that adds a gatling gun that shoots imperial cannonballs (very balanced):

[
    {
        "name": "imperialgatling",
        "icon": "gatling_i",
        "value": 70,
        "platform": "gunplatform",
        "barrel": "gatlinggun",
        "barrelCenter": { "x": 5.5, "y": 5.5 },
        "muzzle": { "x": 30, "y": 0 },
        "shot": "imperialcannon",
        "reload": 140,
        "clipSize": 50,
        "clipReload": 2000,
        "range": 350,
        "sound": "gatling6",
        "soundVolume": 0.65,
        "clipReloadSound": "gatlingreload",
        "clipReloadSoundVolume": 0.65,
        "waitAfterClipReloadSound": 300,
        "outOfAmmoSound": "gatlingnoammo",
        "outOfAmmoSoundVolume": 0.9,
        "fireSquish": 0.9,
        "fireParticle": "gunSmoke",
        "numFireParticles": 1,
        "inaccuracy": 35
    }
]

You can look up the details on each of those values in the section on WeaponType below, but a lot of them should be fairly obvious. (This is just the game data entry for gatlinggun with the shot changed to imperialcannon and the upgrades removed.)

You can also remove items from the game, though be careful, because if other items reference the removed ones, the game will break. For example, if you remove the cannon, the player ships that start with cannons can't find it anymore, and the game will not work.

To remove an item, create an object with the name of the item and "remove": true. For example, this EntityType.json file removes the battleship from the game:

[
    {
        "name": "battleship",
        "remove": true
    }
]

Assets

You can reuse existing images and sounds in the game for your mod. When you want to add new images and sounds to the game, put them into a folder called Assets in your mod. Images should be PNG files, and sounds mono WAV files. When referencing images and sounds in the data, don't include the .png/.wav extension.

Languages

Text visible to the player is stored in the Languages folder. This contains .txt files that map the names of things to their visible text in various languages. To specify which language a file is for, include a line of iso3=language code. Here's an example English.txt file that gives the imperial gatling gun a proper name in English:

iso3=eng
imperialgatling=Imperial Gatling Gun

You don't have to supply text for all of the languages the game supports. Also note that text in manuals has some special rules for showing codes. Numbers enclosed in £ signs are shown as magical codes, e.g. £27142£ will show the code for the giant bee. Numbers enclosed in € signs show the same code in trader symbols. So don't use £ or € in game text otherwise.

Patching Items

If you want to change just a few fields of an existing item, instead of overwriting the whole thing, you can also apply a patch to selectively change it. This also allows your mod to be more compatible with other mods, as multiple mods can make changes to the same item. This is done using JSON Patch. Add an object with the name of the item you want to patch, and a "patch" value containing the list of patch operations you want to apply.

For example, this patch in EntityType.json changes the Copter HP to 10:

[
    {
        "name": "copter",
        "patch": [
            { "op": "replace", "path": "/hp", "value": 10 }
        ]
    }
]

Deriving Items

You can also derive items from pre-existing ones by copying and patching them, which can be a lot more concise. Here's the imperial gatling gun again, but this time deriving from the normal gatling gun:

[
    {
        "name": "imperialgatling",
        "deriveFrom": "gatlinggun",
        "patch": [
            { "op": "replace", "path": "/shot", "value": "imperialcannon" },
            { "op": "remove", "path": "/weaponUpgrades" }
        ]
    }
]

Creating Graphics

If you want to create graphics that match the existing ones in the game, use Inkscape to create them. Thick lines are 0.5mm and thin ones are 0.265mm, exported at 90dpi. You can download an Inkscape file with some example graphics, including the colors and gradients used in the game. Or you can download a massive 27MB Inkscape file that contains most of the game's graphics, though the program may struggle with it a bit.

Gotchas

Some things to keep in mind:

Sound effects should be mono and normalized to 0db. You can adjust their volume in the game data.
The game runs at 125% speed, so if you have a weapon with a 5 second reload, that's actually a 4 second reload and will be shown as such.
The game parameters triple the amount of particles generated, so if you want 3 particles, say you want one.

Settings

You can edit the Settings.json file in the game data to turn on some useful tools for testing the game:

debugKeys: Enable quick cheat keyboard keys: Q to freeze/unfreeze the game, X to gain XP, C to gain money, V to instantly win the level
unlockEverything: Makes all ships, equipment, weapons, and captains available, as if "locked" was set to false for all of them. Does not make all manual pages visible.

Item Type Documentation

A detailed list of the fields of each kind of item. There are a lot of these, so it's best to look at examples of what you want to do in the game data.

Field values are generally one of the following types:

int: Integer numbers such as 3, 7, and 19834
float: Floating-point numbers such as 0.3, 7.1 and 2
bool: Either true or false
string: A piece of text in double quotes, eg "fish"
list: A list of values, such as [1, 2, 3]
object: An object containing keys and values, such as {"fish": 5, "cat": 7}
vec2: A 2D vector, written as {"x": float, "y": float}, e.g {"x": 3, "y": -7}
vec3: A 3D vector, written as {"x": float, "y": float, "z": float}, e.g {"x": 3, "y": -7, "z": 20}. Positive z points out of the screen towards the viewer.
color: A color, written as {"r": 0-255, "g": 0-255, "b": 0-255}, e.g. {"r": 70, "g": 0, "b": 200}
image: Name of an image asset from the game or mod, e.g. "cruiser0"
sound: Name of a sound asset from the game or mod, e.g. "gatling6"

Fields can also reference other item types by name, for example weapons reference EntityTypes for their shots.

Distances are measured in pixels and time is measured in milliseconds. Speeds are hence measured in pixels per millisecond, so a speed of 1 is 1000 pixels per second. Angles are measured in degrees, and rotation speeds in degrees per second. Fields that end in "Pc" generally describe percentage changes. Probabilities are between 0-1, with e.g 0.2 meaning 20% of the time.

For examples on how to use these, look at the existing game data in the Data folder in the game install folder.

DifficultyLevel

tex: image: Icon shown in the difficulty level selector. Approximately 100x100px.
enemiesMult: float: Multiplier for the number of enemies. Also divides the amount of wreckage spawned.
enemyShotSpeedMult: float: Enemy shot speed multiplier.
reloadMult: float: Player reload speed multiplier.
minibossHPPc: int: Percentage change for miniboss (e.g. Clockwork Dragonfly, Wrecker Mothership) HP.
bossHPPc: int: Percentage change for final boss HP.

EntityType

Entities can be players, escorts, enemies, or shots.

Player ships have "starterShip": true, and escorts have "escort": true.

Fields common to all of these:

texs: list of image: Image drawn for the entity or animation frames if there is more than one
texPeriod: int: Interval between animation frames
radius: int: Collision radius
speed: float: Speed or max speed for players, enemies and escorts
moveEmitters: list of ParticleEmitter: Emitters that run while the entity is moving

Players:

shipName: string: Translation key of the name of the ship eg "HMS Fruitbat"
hasCrew: bool: Whether the ship can have a captain and gain experience, default true
staminaTexs: list of image: If the ship has stamina, draw these images to show how much stamina is left
rotors: list of Rotor: Spinning images drawn on top of the ship
engineSound: sound: Sound loop played while the ship is moving
engineSoundVolume: float
moduleSlots: list of ModuleSlot: Module slots for the ship. The first slot is for the doctrine, the second for the captain, and subsequent slots are for normal modules.
equipment: list of EquipmentType: Preinstalled equipment for the ship type
escortSlots: list of EscortSlot: Escort slots
firefightTime: int: Time until fire is extinguished
lazilyRotates: bool: Whether the ship rotates and slides sideways when turning, like the ornithopter
partialEnginePower: float: Multiplier for the ship's speed while sliding sideways when lazily rotating
fullEnginePowerStartAngle: float: The angle between the ship and the ship's intended direction at which engine power starts going from partial to full
fullEnginePowerEndAngle: float: The angle between the ship and the ship's intended direction at which engine power is full
stamina: int: Limited stamina points for the ship, like the pneumopter. The amount of time the ship can move until its stamina is exhausted. 0 means no stamina mechanic
staminaRecovery: int: Time for the stamina to fully recover
minStaminaToMove: int: Minimum amount of stamina to be able to start moving
outOfStaminaSound: sound: Sound played when ship runs out of stamina
outOfStaminaSoundVolume: float
canHaveRam: bool: Whether the ship can have ram modules. By default ships that rotate can have rams.
constantEngineSound: sound: Whether to always play the engine sound loop
repairInterval: int: Time to repair 1 HP, default 12500
repairScrapCost: int: Scrap required to repair 1 HP, default 5
xpMult: float: Multiplier for experience gained
reloadMult: float: Weapon reload multiplier
escortReloadMult: float: Escort weapon reload multiplier
inaccuracyMult: float: Inaccuracy multiplier
damageMult: float: Damage multiplier
explosionDamageMult: float: Explosion damage multiplier
weaponUpgradeCostMult: float: Weapon upgrade cost multiplier
escortUpgradeCostMult: float: Escort upgrade cost multiplier
levelStartScrap: int: Amount of scrap to start each level with, like the supply ship
wreckageAttractRange: int: Distance at which wreckage is picked up, default 100
ramPos: vec2: Location of the ship's ram relative to its center
info: string: Translation key for additional information about the ship. Note that multipliers such as xpMult are not automatically shown and should be described in the info
locked: bool: Whether the ship is unavailable from the start and is unlocked later somehow, default true
unlockAtLevel: int: Unlock the ship when the player first reaches this wave in the game
unlockForACTS: bool: unlock the ship if Airships: Conquer the Skies is also installed

Players, Escorts, and Enemies:

offsetTexs: list of OffsetTexs: Additional images drawn underneath the main texture at an offset. The Y-offset is reduced by the bankAmount when the ship is turning
upperTexs: list of image: Additional frames drawn on top of the main texture, after the weapons are drawn
alwaysAnimate: bool: Always animate the textures even if the ship is not moving
animateWhileNotMoving: bool: Only animate the textures when the ship is moving
acceleration: float: Acceleration in pixels per millisecond squared
maxRotSpeedTime: int: Time until the ship reaches its maximum turn rate
bankAmount: float: Amount by which offsetTexs Y-offsets are squashed when the ship is turning
turnToBankRate: float: Rate at which the ship starts or stops banking when turning. 0 means the ship never banks, 1 means it moves in and out of banking immediately
alwaysMove: bool: The ship always moves towards its heading
weaponSlots: list of WeaponSlot: Places where weapons are placed on the ship
rotates: bool: Whether the ship can rotate, default true
maxTurnRate: float: The maximum rotation speed, in degrees per second

Players and Enemies:

maxHP: int: Maximum hull hit points
maxShields: int: Maximum energy shields
shieldRegenerationInterval: int: Time it takes the shield to regain 1 HP
shieldRadius: int: Collision radius of the shield. Also used to render the shield, so make it big enough that it encloses the ship
flammability: float: Multiplier to likelihood of catching fire
weight: float: Used for resistance to knockback
armor: int: Amount by which incoming collision and explosion damage is reduced
boardingDamageReduction: int: Amount by which incoming boarding damage is reduced. Like armor for boarding damage
explosionDamageReceivedMult: float: Multiplier for damage received from explosions
invulnerable: bool: Makes ship invulnerable to all damage
gibs: list of GibType: Gibs are created when the ship is destroyed
gibVariants: list of list of GibType: List of multiple lists of gibs. Use instead of the gibs field to make the game pick one at random

Players, Shots, and Enemies:

deathParticle: ParticleType: Particle emitted when the entity dies. Ignored if gibs are set
numDeathParticles: int: Number of death particles
hurtParticle: ParticleType: Particle emitted when the entity takes damage
hurtParticle: int: Number of hurt particles
deathSound: sound: Sound played when the entity is destroyed. Ignored if gibs are set
deathSoundVolume: float: Volume of death sound

Shots and Enemies:

collisionDamage: int: Damage done when the entity collides with an opponent
boarding: bool: Whether the damage is boarding damage
explodeRadius: int: When the entity is destroyed, create an explosion with this radius
explodeDamage: int: Damage done by explosion
explodeIgniteChance: float: Chance opponents in the explosion radius catch fire
explodeAfraidChance: float: Chance opponents in the explosion radius become afraid
explodeStunnedChance: float: Chance opponents in the explosion radius become stunned
explodeVulnerableChance: float: Chance opponents in the explosion radius become vulnerable

Enemies:

boardSound: sound: Sound played when the enemy boards the player ship
boardSoundVolume: float
xpGain: int: XP gained by destroying this enemy
overlapPush: float: If the player radius overlaps the radius of this enemy, push the player away with this amount of force
rotateTowardsEnemy: float: If not moving, rotate towards the player at this speed
moveInAngle: float: When moving towards the player, change movement angle by this much
minDist: int: Try to stay at least this much away from the player
maxDist: int: Try to stay at least this close to the player
distMoveCheckWait: int: Interval at which to check if you are too close or far away from the player
dashDist: int: Dash towards the player from this distance
dashWait: int: Wait for this amount of time before starting dash
dashTime: int: Amount of time to dash for
dashSpeed: float: Speed at which to dash
dashSound: sound: Sound to play when dash starts
dashSoundVolume: float
moveRandomly: bool: When not doing anything else move around randomly
newRandomMoveWait: int: Interval between choosing a new random heading when moving randomly
fuzeDist: int: Start a countdown to exploding if at least this close to the player
fuzeWait: int: Time until explosion once the fuze countdown starts
fuzeEmitters: list of ParticleEmitter: Particles emitted during fuze countdown
fuzeSound: sound: Sound to play when fuze countdown starts
fuzeSoundVolume: float
afraidChance: float: Chance that this enemy becomes afraid from a fear effect
stunnedChance: float: Chance that this enemy becomes stunned from a stun effect
vulnerableChance: float: Chance that this enemy becomes vulnerable from a vulnerability effect
spawnOnDeath: EntityType: Create new enemies of this type on death
numSpawnOnDeath: int: Number of enemies to spawn on death
spawn: EntityType: Create new enemies of this type while alive
numSpawn: int: Number of enemies to spawn while alive
spawnInterval: int: Interval between spawning enemies
maxSpawn: int: Maximum total number of spawned enemies in the level at the same time
spawnIncrease: int: Increase numSpawn by this amount after each spawn
spawnOffset: vec2: Location relative to the enemy center where the new enemies are spawned
spawnSound: sound: Sound to play when spawning new enemies
spawnSoundVolume: float
spawnArc: float: Width of arc in which the spawned enemies are sent out, in degrees
spawnArcCenter: float: Center point of spawn arc relative to forward facing
spawnSpeedMin: float: Minimum speed at which spawned enemies are sent out
spawnSpeedMax: float: Maximum speed at which spawned enemies are sent out
spawnParticle: ParticleType: Particle to emit when spawning
numSpawnParticles: int: Number of spawn particles
boss: bool: Whether this enemy is a final boss
miniboss: bool: Whether this enemy is a mini boss, like a Wrecker Mothership or Mechanical Dragonfly
keepApart: int: Amount by which this enemy tries to keep away from other enemies, 10 is a normal value, default is 0
keepAwayFromBorder: int: Amount by which this enemy tries to keep away from the edge of the map, default is 10
wreckageType: WreckageType: Type of wreckage dropped on death
wreckage: float: Amount of wreckage dropped on death. Can be a non-integer number to represent the average amount dropped, eg 1.5
hasManualEntry: bool: Whether this enemy has an entry in the manual
tentacles: list of Tentacle: List of tentacles attached to this enemy
rotatingShields: list of EntityType: Additional enemies that appear rotating around this enemy
rotatingShieldSpeed: float: Speed at which the shields spin around this enemy
rotatingShieldDist: int: Distance at which the shields spin around this enemy
transformInto: EntityType: Turn into an enemy of this type after a certain amount of time
transformAfterTime: int: Time after which this enemy transformes
transformTexs: list of image: Animation frames shown instead of the normal texs just before transforming
transformTexPeriod: int: Interval between transformTex frames
unlockPageName: ManualPage: When the player first kills this enemy type, unlock this manual page instead of the normal one

In addition, enemies also have all the fields of ManualPage items.

Escorts:

value: int: The cost of the escort in $
canBuy: bool: Whether this escort can be bought in the upgrades shop, default true
pickupWreckage: bool: Makes the escort pick up wreckage
pickupWreckageInterval: int: After picking up wreckage, become slower for this amount of time
firefightCharges: int: Number of times the escort can extinguish a burning player ship
firefightChargeInterval: int: Cooldown between extinguishing the player ship
repairCharges: int: Number of times the escort can repair a player ship
repairChargeInterval: int: Cooldown between repairing the player ship
maxDistFromPlayer: int: Maximum distance away from the player the escort will move
attackLargestEnemy: bool: Attack the enemy with the most HP instead of the closest one
preferUnarmoredTargets: bool: Pick enemies to attack that have little or no armor
escortEquipment: EquipmentType: Equipment that counts as being installed on the player ship when they have this escort
upgrades: list of EscortUpgrade: Upgrades for the escort
minDist: int: Try to stay at least this much away from enemies you're attacking

Shots:

hitParticle: ParticleType: Particle emitted when the shot hits
numHitParticle: int: Number of hit particles
unarmedTexs: list of image: If the shot has a minimum range, it only becomes active once it's past that range. You can override its appearance during this inactive period with these images
damageSound: sound: Sound played on shot impact
damageSoundVolume: float
collisionIgniteChance: float: Chance opponent catches fire when the shot collides with it
collisionAfraidChance: float: Chance opponent becomes afraid when the shot collides with it
collisionStunnedChance: float: Chance opponent becomes stunned when the shot collides with it
collisionVulnerableChance: float: Chance opponent becomes vulnerable when the shot collides with it
guidedTurnRate: float: Rotate towards the shot target at this rate
piercing: int: Number of opponents the shot pierces through, dealing damage. If set to -1, the shot pierces through any number of opponents. Default 0
wreckageMult: float: Increase the amount of wreckage produced by the hit opponent. Does not stack, but the largest multiplier is applied
spinSpeed: float: Rotate the shot graphic at this speed
targetLockArc: float: Arc width in degrees beyond which a guided shot loses track of its opponent
canLoseTargetLockAfterTime: int: Time after which a guided shot can lose track of its opponent

EscortUpgrade

info: string: Translation key for info about upgrade choice
type: EntityType: Type the escort upgrades into

WeaponSlot

offset: vec2: Location relative to ship center where the weapon is located
weapon: WeaponType: Weapon installed in slot

ModuleSlot

module: EquipmentType: Module installed in slot

EscortSlot

escort: EntityType: Escort installed in slot

Rotor

tex: image: Image of rotor
offset: vec2: Location relative to ship center
speed: float: Rotation speed
initialRotation: float: Initial rotation in degrees

OffsetTexs

texs: list of image: Animation frames
offset: vec2: Location relative to ship center

Tentacle

texs: list of image: List of tentacle segment images. Each tentacle segment uses a randomly chosen one from this list
numSegments: int: Number of tentacle segments
basePos: vec2: Location where the tentacle is attached relative to the owning ship or weapon slot
baseAngle: float: Angle at which the tentacle sticks out relative to the owning ship heading
baseWidth: float: Tentacle segment width at base
baseLength: float: Tentacle segment length at base
baseStiffness: float: Tentacle segment stiffness at base, on a scale from 0 (completely floppy, do not use) to 1 (immovable, do not use)
tipWidth: float: Tentacle segment width at the tip
tipLength: float: Tentacle segment length at the tip
tipStiffness: float: Tentacle segment stiffness at the tip, on a scale from 0 (completely floppy, do not use) to 1 (immovable, do not use)
suckerDirection: bool: Whether to flip the image segments
straightenMult: float: Multiplier for the speed at which the tentacle re-straightens
absoluteTargeting: bool: Whether the tentacle should target absolute locations in the level rather than locations relative to its owner
betweenSweepTime: int: Time interval between attacks
warnTime: int: Time period to show the tentacle sweep area before attacking
anticipateTime: int: Time period where the tentacle moves backwards slightly in anticipation for the attack
recoilTime: int: Time period where the tentacle moves backwards if it hits something
sweepArcCenter: float: Center of the arc within which the tentacle can attack
sweepArc: float: Width of the arc within which the tentacle can attack
sweepDistMin: int: Minimum distance from base to which the tentacle sweeps
sweepDistMax: int: Maximum distance from base to which the tentacle sweeps
maxSweepTime: int: Maximum amount of time a sweep takes
speed: float: Speed multiplier for tentacle movements
knockback: float: Strength with which the tentacle knocks back enemies
damage: int: Damage done by tentacles
attackPlayerChance: float: Chance the tentacle attacks the player rather than moving randomly, default 1
initialWait: int: Initial time in the level before the tentacles start moving
wreckageMult: float: Multiplier for opponent wreckage dropped when hit by this tentacle
knockAway: bool: On hit, knock the opponent away from the center of the tentacle's ship rather than from the tentacle, default false
detachPoint: int: Segment index at which the tentacle should detach from the ship when it does
detachSegmentRot: float: Rotation speed of the detached tentacle
detachTex: image: Image override for the segment where the tentacle was detached
segmentOverrides: list: List of {"tex": image, "scale": float} visual overrides to specific segments.
tipStartX: int: Initial x-position of the tip relative to the base
tipStartY: int: Initial y-position of the tip relative to the base

GibType

Visual fragments of a destroyed entity spawned upon its death. Gibs can spawn additional gibs when they die.

texs: list of image: Animation frames
lifespan: int: Time until the gib is destroyed
sound: sound: Sound played when the gib is created
soundVolume: float
deathSound: sound: Sound played when the gib is destroyed
deathSoundVolume: float
vibrate: bool: Whether the gib should vibrate
rotate: float: Rotation speed of the gib. The clockwise/anticlockwise direction is random and the amount is varied by +-50%
emitters: list of ParticleEmitter: Particles emitted by the gib
offset: vec3: Position relative to the center of the destroyed entity
speed: vec3: Speed at which the gib moves away from the center. The angle of this is randomized by +-30 degrees
explosionRadius: int: Radius of non-damaging explosion created on gib destruction
particle: ParticleType: Particle spawned when the gib is created
numParticles: int: Number of particles spawned when the gib is created
deathParticle: ParticleType: Particle spawned when the gib is destroyed
numDeathParticles: int: Number of particles spawned when the gib is destroyed
fade: bool: Whether the gib fades away over time, becoming transparent, default true
gibs: list of GibType: Gibs to spawn at positions relative to this gib when it's destroyed

EquipmentType

EquipmentType covers modules, upgrades purchased with $, trainings purchased with XP, doctrines, and captains.

temporary: bool: Whether this is a temporary effect that should be removed at level end. Used by stelas
locked: bool: Whether this equipment needs to be unlocked in some way before becoming available
unlockOnFirstVictory: bool: Unlock when the player wins their first run
icon: image: Image shown in the upgrade screen. Should be no more than 93x93px. If this equipment is a captain, it should be exactly 93x93px
canBuy: bool: Whether this equipment can be bought by the player
value: int: Purchase cost in $
xpValue: int: Purchase cost in XP
isCaptain: bool: Whether this equipment is a captain
isModule: bool: Whether this equipment is a module
isDoctrine: bool: Whether this equipment is a doctrine
isPermanentBonus: bool: Whether this equipment is a permanent bonus added to all ships once it's unlocked
needsCrew: bool: This equipment needs a ship with crew
oneOnly: bool: Can only have one of these
radiusPc: int: Percent change of ship collision radius
repairSpeedPc: int: Percent change of repair speed
repairScrapCost: int: Change in amount of scrap needed to repair
sellValueMultPc: int: Percent change in how much selling escorts, modules, and weapons is worth
scrapToMoneyRatePc: int: Percent change of how much money remaining scrap is turned into at the end of a level
endOfLevelMoney: int: Amount of money gained at the end of each level
weaponUpgradeCostPc: int: Percent change of how much it costs to upgrade weapons
escortUpgradeCostPc: int: Percent change of how much it costs to upgrade escorts
weaponCostPc: int: Percent change of how much it costs to buy weapons
moduleCostPc: int: Percent change of how much it costs to buy modules
escortCostPc: int: Percent change of how much it costs to buy escorts
reloadPc: int: Percent change of weapon reload speed
accuracyPc: int: Percent change of weapon accuracy
damagePc: int: Percent change of weapon non-explosion damage
explosionRadiusPc: int: Percent change of weapon explosion radius
explosionDamagePc: int: Percent change of weapon explosion damage
explodeIgniteChancePc: int: Chance that explosions make enemies catch fire
explodeAfraidChancePc: int: Chance that explosions make enemies become afraid
explodeStunnedChancePc: int: Chance that explosions make enemies stunned
explodeVulnerableChancePc: int: Chance that explosions make enemies vulnerable
rangePc: int: Percent change of non-melee weapon range
xpPc: int: Percent change of XP gain
armor: int: Armor points
boardingDamageReduction: int: Reduction in boarding damage
fireDamagePc: int: Percent change of damage done by fire
firefightSpeedPc: int: Percent change of speed at which fires are put out
speedPc: int: Percent change of ship speed
turnRatePc: int: Percent change of ship turn rate
wreckageAttractRange: int: Change to distance at which wreckage is collected
maxHPPc: int: Percent change of HP
extraHP: int: Fixed amount of additional HP
ramDamage: int: Damage done by ramming if this is a ram module, or increased damage from ramming otherwise
ramAfraidChancePc: int: Chance ramming an enemy makes it afraid
ramStunnedChancePc: int: Chance ramming an enemy makes it stunned
ramVulnerableChancePc: int: Chance ramming an enemy makes it vulnerable
ramTex: image: Image of ram. If this is set, this equipment is a ram
ramRadius: int: Radius at which the ram collides with enemies. The location of the ram is set by the ship's ramPos field
ramDamagePerArmor: float: Additional damage done by rams per ship armor point
ramSound: sound: Sound played when ramming an enemy
ramSoundVolume: float
canRamWhileStopped: bool: The ram works even when the ship is not moving forward
flammabilityPc: int: Percent change in ship flammability
vulnerableChancePc: int: Percent change in ship vulnerability chance
stunnedChancePc: int: Percent change in ship stun chance
afraidChancePc: int: Percent change in ship fear chance
shields: int: Amount of energy shields
shieldRegenerationSpeedPc: int: Percent change in energy shield regeneration time
noOtherShields: bool: Prevents other equipment that creates energy shields from being available
shieldTex: image: Image override for the energy shield bubble
shieldSoundVolume: float
shieldSound: sound: Override for sound played when the shield is hit
shieldRepairSound: sound: Override for sound played when the shield regenerates
shieldRepairSoundVolume: float
shieldParticle: ParticleType: Override for particle spawned when the shield is hit
shieldRepairParticle: ParticleType: Override for particle spawned when the shield regenerates
escorts: int: Change in number of escort slots
escortRoamRangePc: int: Percentage change of escorts' maxDistFromPlayer
upgrades: list of EquipmentUpgrade: List of possible upgrades, only applies to modules and doctrines
fireAura: int: Interval for nearby enemies catching fire
afraidAura: int: Interval for nearby enemies becoming afraid
stunnedAura: int: Interval for nearby enemies becoming stunned
vulnerableAura: int: Interval for nearby enemies becoming vulnerable
fireContagion: int: Interval for fire jumping from one enemy to the next
afraidContagion: int: Interval for fear jumping from one enemy to the next
stunnedContagion: int: Interval for stun jumping from one enemy to the next
vulnerableContagion: int: Interval for vulnerability jumping from one enemy to the next
afraidAlsoStunned: bool: All afraid enemies are also stunned
afraidAlsoVulnerable: bool: All afraid enemies are also vulnerable
afraidCatchesFire: bool: All afraid enemies also catch fire
stunnedAlsoAfraid: bool: All stunned enemies are also afraid
stunnedAlsoVulnerable: bool: All stunned enemies are also vulnerable
stunnedCatchesFire: bool: All stunned enemies also catch fire
vulnerableAlsoAfraid: bool: All vulnerable enemies are also afraid
vulnerableAlsoStunned: bool: All vulnerable enemies are also stunned
vulnerableCatchesFire: bool: All vulnerable enemies also catch fire
onFireAlsoStunned: bool: All All burning enemies are also stunned
onFireAlsoVulnerable: bool: All burning enemies are also vulnerable
onFireAlsoAfraid: bool: All burning enemies are also afraid
suitableForCardinalMovement: bool: Whether this equipment can be used by ships with rotate set to false. Default true
wreckageXP: int: XP gained from picking up a piece of wreckage
escortReloadPc: int: Percent change of escort reload speed
extraPiercing: int: Additional piercing for weapons that are already piercing
globalFireDamagePc: int: Percent change of fire damage for everyone
selfVulnerable: bool: Ship is permanently vulnerable
enemiesVulnerable: bool: All enemies are vulnerable
selfStunned: bool: Ship is permanently stunned
enemiesStunned: bool: All enemies are stunned
enemiesAfraid: bool: All enemies are afraid
enemyKnockbackWhenDamageTaken: float: Force by which to knock back nearby enemies when taking damage
convertMoneyToXPAtEndOfWavePc: int: Gain this percentage of accumulated money as XP at the end of each level
afraidEnemyWreckagePc: int: Percentage change of wreckage dropped by enemies that were afraid when they died
stunnedEnemyWreckagePc: int: Percentage change of wreckage dropped by enemies that were stunned when they died
vulnerableEnemyWreckagePc: int: Percentage change of wreckage dropped by enemies that were vulnerable when they died
preventUpgradeRefreshAndLock: bool: Prevent the player from refreshing the upgrade shop or locking upgrades
repeatedUpgradesCostPc: int: Percent change in how much each repeat upgrade of the same type costs in $
upgradeRefreshCostPc: int: Percent change of how much XP it costs to refresh the upgrade shop
halo: color: Show a halo of this color around the ship
mapLoops: bool: Allow the ship to teleport from one end of the level to the other
preventDeaths: int: Prevent this number of deaths each level, resurrecting the player if they hit 0 HP
enemyShotSpeedPc: int: Percent change in the speed of enemy shots
enemySpeedPc: int: Percent change in the speed of enemies
auraRadiusPc: int: Percent change in the distance at which enemies are considered nearby
wreckagePc: int: Percent change in wreckage dropped by enemies
grantXP: int: Grant this amount of XP when purchased
cancelFireResistances: bool: Cancel all fire resistances for the player and enemies
cancelStunResistances: bool: Cancel all stun resistances for the player and enemies
cancelFearResistances: bool: Cancel all fear resistances for the player and enemies
cancelVulnerableResistances: bool: Cancel vulnerability resistances for the player and enemies
allWeaponsArePiercing: bool: All non-exploding weapons have a piercing of at least 1
alwaysOnFire: bool: The ship is always on fire and cannot be extinguished
maxDamageCap: int: Maximum amount of hull damage received at one time
chasedBy: EntityType: Spawn a number of these enemies at the start of each wave
numChasedBy: int: The number of enemies to spawn
startMapStats: object of faction names to ints: Initial faction reputation when starting the game
links: list of Link: Modify a ship stat relative to another stat. Allows for effects like "+15 damage per armor point"
whenStopped: bool: Equipment only provides its effects when the ship is stopped
whenAtFullHP: bool: Equipment only provides its effects when the ship is at full HP
whenAtLessThanHalfHP: bool: Equipment only provides its effects when the ship is at less than half HP
whenDamageTakenSince: int: Equipment only provides its effects when the ship has taken damage within this time interval
whenNoDamageTakenSince: int: Equipment only provides its effects when the ship has not taken damage within this time interval
whenRepairedSince: int: Equipment only provides its effects when the ship has been repaired within this time interval
whenNotRepairedSince: int: Equipment only provides its effects when the ship has not been repaired within this time interval
whenFiredSince: int: Equipment only provides its effects when the ship has fired a weapon within this time interval
whenNotFiredSince: int: Equipment only provides its effects when the ship has not fired a weapon within this time interval
whenWreckagePickedUpSince: int: Equipment only provides its effects when the ship has picked up a piece of wreckage within this time interval
whenNoWreckagePickedUpSince: int: Equipment only provides its effects when the ship has not picked up a piece of wreckage within this time interval
tags: list of string: Tags for what kind of equipment this is, used by likes and dislikes in WeaponType, EquipmentType and MapNodeType
likes: list of string: Make this equipment more likely to turn up in the shop if the player already has equipment or weapons with these tags

EquipmentUpgrade

info: string: Translation key for description of upgrade
type: EquipmentType: Type to upgrade the equipment to

Link

Links allow equipment to connect almost any ship stat to any other. For example, linking from Armor to DamageMult means the ship gains damage the more armor it has. Note that if you accidentally create a cycle of links, the game will crash. Also note that links don't work for enemies for performance reasons.

Ship stats have different names than the equipment field names, and are listed below.

Link fields:

to: string: The ship stat to modify
from: string: The ship stat to use as a basis for the modification
ratio: float: The rate at which the "from stat is converted to the "to" stat
mode: string: One of "fromChange" (the "to" stat is always modified), "fromIncrease" (the "to" stat is only modified if "from" > 0), "fromDecrease" (the "to" stat is only modified if "from" < 0)

Stats than can be used for both "from" and "to":

Armor
BoardingDamageReduction
ExtraHP
MaxShields
RamDamage
ExtraPiercing
FlammabilityMult
VulnerableChanceMult
StunnedChanceMult
AfraidChanceMult
MaxDamageCap
WreckageAttractRange
RepairScrapCost
EndOfLevelMoney
EnemyKnockbackWhenDamageTaken
WreckageXP
ConvertMoneyToXPAtEndOfWaveMult
PreventDeaths
ReloadMult
AccuracyMult
RangeMult
DamageMult
RadiusMult
ExplosionRadiusMult
ExplosionDamageMult
ExplosionIgniteChance
ExplosionAfraidChance
ExplosionStunnedChance
ExplosionVulnerableChance
FirefightTimeMult
MaxTurnRateMult
SpeedMult
MaxHP
ShieldRegenerationIntervalMult
FireDamageIntervalMult
RamAfraidChance
RamStunnedChance
RamVulnerableChance
EscortRoamRangeMult
AuraRadiusMult
WreckageMult
RepairSpeedMult
SellValueMult
ScrapToMoneyRateMult
EscortUpgradeCostMult
UpgradeRefreshCostPc <- ???
WeaponUpgradeCostMult
WeaponCostMult
ModuleCostMult
EscortCostMult
XPMult
EscortReloadMult
GlobalFireDamageMult
AfraidEnemyWreckageMult
StunnedEnemyWreckageMult
VulnerableEnemyWreckageMult
EnemyShotSpeedMult
EnemySpeedMult
RepeatedUpgradesCostMult

Note that stats ending in Mult are multipliers (e.g 0.2) rather than percentages. So when converting from an integer number to a multiplier, use the right ratio, e.g. 0.15 to convert 1 armor to 15% damage.

Additional stats that can be used for "from":

Money
XP
Scrap
AfraidEnemies
StunnedEnemies
VulnerableEnemies
OnFireEnemies
NearbyEnemies
NumEscorts

LandscapeType

tex: image: Background image 3177x3177px
lut: image: Color grading lookup table to apply
zones: list of ZoneType: Zones that can appear

LevelType

icon: image: Image shown in the center of the screen at the start of the level
mapIcon: image: Icon used in the world map, should be a 68x68px white on transparent image in a circle
wave: list of Wave: Information about which enemies spawn in this level
boss: bool: Whether this is a final boss level
music: sound: Override for the level music
musicVolume: float

Wave

A set of enemies that spawn during a level.

start: int: Time at which these enemies start spawning, in seconds
end: int: Time at which these enemies stop spawning, in seconds
interval: int: Time interval between spawning, in seconds
enemy: EntityType: Type of enemy that spawns
quantity: float: Number of enemies that spawns. This is modified by the difficulty level and the wave number
quantityPerSpawn: float: Amount by which the quantity increases each time the spawn happens. This is modified by the difficulty level and the wave number
scaleQuantity: bool: Whether to modify the quantity of enemies spawned based on the difficulty level and the wave number, default true
spawnMode: string: Pattern in which the enemies spawn. See list below
clusterRadius: int: Radius of enemy cluster, if applicable to spawn mode
x: float: Enemy x-position, if applicable to spawn mode
y: float: Enemy y-position, if applicable to spawn mode
rot: float: Enemy rotation, if applicable to spawn mode

Spawn modes:

proportional: Position the enemy on the level map with the rotation specified and at a location relative to the entire map. For example, x: 0.5, y: 1 would place it at the center bottom
cluster: Position a cluster of enemies in a random location
sideCluster: Position a cluster of enemies at a random map edge
random: Place enemies at random
topRandom: Place enemies at random along the top of the map
bottomRandom: Place enemies at random along the bottom of the map
leftRandom: Place enemies at random along the left of the map
rightRandom: Place enemies at random along the right of the map
ring: Place enemies in a ring around the player at a distance of clusterRadius

ManualPage

Manual pages (which include enemies) have lore text with the translation key name_lore.

code: int: The symbol code associated with this page. Must be a five-digit number with the digits 1-9. Make sure it's unique
illustration: image: Illustration shown in top left of the page
hasScrawl: bool: Whether there is a scrawled note on the page. The scrawl has the translation key name_scrawl
loreIsScrawl: bool: Whether the main page text is in the font of the scrawled notes
scrawlX: int: X-position of the scrawl on the page
scrawlY: int: Y-position of the scrawl on the page
scrawlAngle: float: Rotation of the scrawl
crossreferences: list of ManualPage: Manual pages listed under "See also:"
photo: image: Image shown on the right page of the manual entry
hasExtraLore: bool: Show additional lore text once the page has been researched. The extra lore has the translation key name_extraLore
researchMinutes: int: Number of minutes required to research the page
researchKillEnemy: EntityType: Enemy to kill to research the page. If this page is also an enemy EntityType, defaults to that
researchMinutesPerKill: int: Research minutes gained from killing one enemy
researchMinutesPerUpgradeRefresh: int: Research minutes gained from refreshing the upgrade store
researchWinWithValueBelow: string: Finish research if the player wins with this ship stat (see Links above) is lower than researchWinAmt
researchWinWithValueAbove: string: Finish research if the player wins with this ship stat (see Links above) is higher than researchWinAmt
researchWinAmt: float
researchWinWeaponTypes: list of WeaponType: Finish research if the player wins with at least researchWinAmt of any of the weapons listed
researchWinEquipmentTypes: list of EquipmentType: Finish research if the player wins with at least researchWinAmt of any of the equipment listed
researchWinEscortTypes: list of EntityType: Finish research if the player wins with at least researchWinAmt of any of the escorts listed
researchWinShipType: EntityType: Finish research if the player wins with this ship type
researchSpecialConditionText: string: Translation key for describing a custom research condition apart from killing enemies
unlockShip: EntityType: Unlock this ship upon finishing the research
unlockCaptain: EquipmentType: Unlock this captain upon finishing the research
unlockEquipment: EquipmentType: Unlock this equipment upon finishing the research
unlockWeapon: WeaponType: Unlock this weapon upon finishing the research
unlockEscort: EntityType: Unlock this escort upon finishing the research
unlockBonus: EquipmentType: Unlock this permanent upon finishing the research. It will be applied to all ships in future runs

MapNodeType

A location on the world map. If there are multiple possible rewards, one is chosen at random.

baseIcon: Texture2D: Icon used in the world map, should be a 68x68px white on transparent image in a circle. Overridden by the mapIcon of the LevelType chosen if that's available
levels: list of LevelType: List of level types to pick from randomly
landscape: LandscapeType: Landscape type for background
rewardMoney: int: Money gained from finishing the level
rewardXP: int: XP gained from finishing the level
rewardWeapons: list of WeaponType: List of weapon rewards for finishing the level
rewardEquipments: list of EquipmentType: List of equipment rewards for finishing the level
rewardEscorts: list of EntityType: List of escort rewards for finishing the level
rewardWeaponUpgrade: bool: Upgrade a random weapon as a reward for finishing the level
rewardEscortUpgrade: bool: Upgrade a random escort as a reward for finishing the level
rewardMapStat: string: Name of a reputation value, e.g "Pirates" to change when finishing the level
rewardMapStat2: string: Second map stat to change
rewardMapStatAmount: int: Change in map stat
rewardMapStatAmount2: int: Change in second map stat
minWave: int: The earliest wave this map node will appear in on the map
maxWave: int: The latest wave this map node will appear in on the map
boss: bool: This is a final boss node
difficulty: string: Translation key for difficulty level
quantityMult: float: Multiply the number of enemies by this amount
tempEscorts: list of EntityType: List of escorts to be temporarily given to the player for this level
weapons: int: Number of weapons in upgrade shop
modules: int: Number of modules in upgrade shop
upgrades: int: Number of upgrades in upgrade shop
xpUpgrades: int: Number of trainings in upgrade shop
escorts: int: Number of escorts in upgrade shop
minCost: int: Minimum cost of items in the upgrade shop, to prevent low-level upgrades
maxCostMult: float: Multiplier for maximum cost of items in the upgrade shop. The base value is 80 + wave number * 50
costMult: float: Multiplier for cost of items in upgrade shop
likes: list of string: Equipment and weapons with these tags turn up more frequently in the upgrade shop
dislikes: list of string: Equipment and weapons with these tags don't turn up in the upgrade shop
scrapValueMultPc: int: Percent change of value of scrap sold at the end of the level
helpEquipment: EquipmentType: Equipment permanently given to the player before the level starts
alternatives: list of MapNodeAlternative: List of alternatives unlocked by map stats

Note: You can introduce new map stats by mentioning them. They need an white-on-transparent image called "faction name" no bigger than 32x32px for displaying in the top bar of the map.

MapNodeAlternative

Gives the player the option to play an alternative version of a node if a reputation stat is high enough, eg "fight this monster with the help of your allies".

stat: string: The map stat to check
amount: int: Minimum map stat value to unlock this alternative
type: MapNodeType: The alternative MapNodeType unlocked

MapType

tex: image: 9003x1090px background image of the map
nodes: list: Map nodes written as [level, x, y]. Level 19 is the boss fight.
connections: list: Connections between map nodes written as [from index, to index]. The indexes are 0-based.

ParticleType

tex: image: Image used for the particle, white on transparent
color: color: Particle color
endColor: color: If set, the particle color transitions between color and endColor through its life
speed: float: Particle speed, randomized by +-50%
lifespan: int: Particle lifespan, randomized by +-50%
shrink: bool: The particle shrinks over time
randomRotation: bool: Randomly rotate the particle image

ParticleEmitter

type: ParticleType: Type of particle to emit
p: float: Probability per millisecond that a particle is emitted
offset: vec2: Relative position where particles are emitted

WeaponType

icon: image: Image shown in upgrade shop, max 93x93px
canBuy: bool: Can buy the weapon in the upgrade shop
locked: bool: Whether this weapon needs to be unlocked in some way before becoming available
value: int: Purchase cost in $
suitableForCardinalMovement: bool: Whether this equipment can be used by ships with rotate set to false. Default true
platform: image: Image of weapon platform rendered below barrel
barrel: image: Weapon barrel
saw: image: Rotating sawblade image
sawOffset: vec2: Location of the sawblade image
barrelGlow: image: Image drawn after the platform but before the barrel, becomes bigger as the weapon gets ready to fire
barrelCenter: vec2: Rotation center point in barrel image
muzzle: vec2: Relative location of where shots are created when firing
offset: vec2: Offset relative to ship heading where shots are spawned
fireSquish: float: When the weapon fires, its barrel length is temporarily multiplied by fireSquish
fireParticle: ParticleType: Particle emitted when firing
fireParticleShootDir: float: Adjusts fire particle velocity vector. 0 means the particles go in all directions, 1 means they all go in line with the shot. Default 0.5
numFireParticles: int: Number of fire particles
shot: EntityType: Shot created by weapon
numShots: int: Number of shots created, default 1
reload: int: Time between weapon firing
range: int: Maximum range
displayedRange: int: Override for displayed range
minRange: int: Minimum range. Weapon will not target enemies within minimum range, and its shots will not be active until they are out of minimum range
sound: sound: Sound played when firing
soundVolume: float
fireArc: float: Arc width of where the weapon can aim. Default is 0, which means no limit to the fire arc
fireArcCenter: float: Angle of center of fire arc relative to ship heading
cardinalControlsFireArc: float: Arc width of where the weapon can aim when the player is in cardinal controls mode
inaccuracy: float: Maximum weapon inaccuracy in degrees
extraInaccuracyIfNoEyes: float: Additional inaccuracy if there are no enemies of eyeType in the level
eyeType: EntityType: Enemy type to check for extraInaccuracyIfNoEyes effect
clipSize: int: If set to > 0, the weapon needs to reload its clip every clipSize shots
clipReload: int: Time required to reload clip
clipReloadSound: sound: Sound played when clip is reloaded
clipReloadSoundVolume: float
waitAfterClipReloadSound: int: Time to wait after the clip reload sound is played until the weapon is ready to fire again. So the total time taken to reload is clipReload + waitAfterClipReloadSound
outOfAmmoParticle: ParticleType: Particle emitted when the clip is empty
numOutOfAmmoParticles: int: Number of out of ammo particles
reloadParticle: ParticleType: Particle emitted when the clip is reloaded
numReloadParticles: int: Number of reload particles
outOfAmmoSound: sound: Sound to play when the clip is empty
outOfAmmoSoundVolume: float
mine: bool: Weapon is a stationary mine
targetToughestEnemy: bool: Weapon targets in-range enemy with most HP instead of closest enemy
leadFactor: float: Factor by which the weapon compensates for enemy movement, default 0.3
melee: bool: Whether this is a melee weapon, which means it's not affected by range modifiers
kickbackSpeed: float: Force with which the ship firing the weapon is pushed back
fireAura: int: Interval for nearby enemies catching fire
afraidAura: int: Interval for nearby enemies becoming afraid
stunnedAura: int: Interval for nearby enemies becoming stunned
vulnerableAura: int: Interval for nearby enemies becoming vulnerable
autofire: bool: Automatically fire the weapon in random directions even if there are no valid targets
ignoreRange: bool: Fire the weapon at enemies even if they're out of range
speedVariation: float: Factor by which to vary the shot speed, default 0
tentacles: list of Tentacle: Tentacles attached to this weapon. See tentacle documentation above
upgrades: list of WeaponUpgrade: List of upgrades available for this weapon
tags: list of string: Tags for what kind of weapon this is, used by likes and dislikes in WeaponType, EquipmentType and MapNodeType
likes: list of string: Make this weapon more likely to turn up in the shop if the player already has equipment or weapons with these tags

WeaponUpgrade

info: string: Translation key for description of upgrade
type: WeaponType: Weapon type to upgrade to

WreckageType

The glowing things dropped by enemies that the player can pick up.

tex: image: Image of wreckage
money: int: Money gained from picking up
scrap: int: Scrap gained from picking up
spinSpeed: float: Speed at which the wreckage spins
pulsateAmount: float: Amount by which the wreckage becomes bigger and smaller, default 0
sound: sound: Sound played when wreckage is picked up
soundVolume: float

ZoneType

Zones are areas with localized effects such as stelas, friendly ports and weather conditions like sandstorms.

texs: list of image: Animation frames for the zone appearance
lut: image: Color grading LUT to apply when the player is inside the zone
drawLate: bool: Draw on top of the player, enemy and shots. Default false
texPeriod: int: Interval between animation frames
texsAreLayers: bool: Draw all textures at once on top of each other
texRotationSpeed: float: Spin the texture(s) at this speed
emitters: list of ParticleEmitter: Emit particles at specific points
insideSound: sound: Sound loop to play while the player is inside the radius
insideSoundVolume: float
particle: ParticleType: Particles to create inside the zone
particleSpeed: float: Spawned particle speed
particleSpawnP: float: Probability of spawning a particle
radius: float: Radius in which the zone has an effect
damageInterval: int: Interval for doing 1 point of damage to everyone inside the radius, default 0 for no damage
extinguishesFire: bool: Extinguishes burning players and enemies
shootInInaccuracyMultiplier: float: Shots fired at players and enemies inside have their inaccuracy multiplied by this
afraidTime: int: Time after which enemies in the zone become afraid
stunnedTime: int: Time after which players and enemies in the zone become afraid
vulnerableTime: int: Time after which players and enemies in the zone become vulnerable
onFireTime: int: Time after which players and enemies in the zone catch fire
grantsEquipment: EquipmentType: Give this temporary equipment to players and enemies in the zone, remove it again when they leave
pushSpeed: float: Speed at which players and enemies are pushed along in the direction of the zone
info: string: Translation key for info lines shown in top left when the player is in the zone
playerOnly: bool: Zone effects apply to player only, default false
driftVolume: float: Volume at which the sound effect for drifting sideways is played while the player is in the zone, default 1

Parameter

These change game balance and work a bit differently. All items have a name and a value. Here are the names and the types of the values:

pMapSize: float: Multiplier to level map size
pEnemyHP: float: Multiplier to enemy HP
pEnemies: float: Multiplier to number of enemies
pAcceleration: float: Multiplier to player acceleration
pRotationAccelerationTime: float: Multiplier to player rotation acceleration
pEnemyAccuracy: float: Multiplier to enemy accuracy
pWaveLength: float: Multiplier to wave length
pFireDamage: float: Multiplier to fire damage taken by players and enemies
pEquipmentCost: float: Multiplier to equipment cost in $
pXPCost: float: Multiplier to training and doctrine cost in XP
pWeaponUpgradeCost: float: Multiplier to weapon upgrade cost
pWeaponCost: float: Multiplier to weapon cost
pXPCostIncrease: float: Multiplier to how quickly XP costs for trainings increase
pUpgradeCostIncrease: float: Multiplier to how quickly $ costs for upgrades increase
pParticleQuantity: float: Multiplier to number of particles in the game
pParticleLife: float: Multiplier to particle lifespan
pParticleSize: float: Multiplier to particle size
pParticleSpeed: float: Multiplier to particle speed
pPlayerFireRate: float: Multiplier to player fire rate
pEscortFireRate: float: Multiplier to escort fire rate
pSoundDistanceAttenuation: float: Amount by which far away sounds are reduced in power
pZoneEnemyDamage: float: Multiplier to player damage taken in zone
pGameSpeed: float: Multiplier to game speed
pXP: float: Multiplier to XP gained
pWreckage: float: Multiplier to wreckage dropped
pBaseWaveQuantity: float: Multiplier to how many enemies spawn from the start
pWaveQuantityIncrease: float: Multiplier to how many more enemies spawn with increasing wave numbers
pPlayerBaseHP: float: Multiplier to starting HP of player ships
pStunSpeed: float: Multiplier to enemy speed when stunned
pPlayerStunSpeed: float: Multiplier to player speed when stunned
pVulnerableDamage: float: Multiplier to damage taken when vulnerable
pMinibossHP: float: Multiplier for miniboss HP
pBossHP: float: Multiplier for boss HP
pAuraSpeed: float: Multiplier for speed at which aura effects happen
pMinibossStartHPPc: int: Percentage change of miniboss HP
pMinibossHPPcPerLevel: int: Percentage change of miniboss HP per level number
pMinibossStartReloadPc: int: Percentage change of miniboss reload speed
pMinibossReloadPcPerLevel: int: Percentage change of miniboss reload speed per level number
pOutOfDepthNodeChance: float: Likelihood that a map node is of a MapNodeType that's higher than normal
pOutOfDepthLevelBoost: int: Number of wave levels that an out of depth node is higher than normal
pSellValue: float: Multiplier for money gained from selling a weapon, escort, or module