This page documents the legacy content-pack .txt parameters read by the classes in com.flansmodultimate.common.types.

The source of truth for this page is the current Java parser code. Some legacy keys are aliases for the same internal field; those aliases are shown together.

• Keywords are case-insensitive.
• Most scalar values use Key value. Key = value is also accepted for scalar reads.
• Boolean values accept true, false, 1, or 0.
• Repeated scalar keys usually use the last non-empty value.
• Repeated line-list keys, such as Ammo, Paintjob, AddRound, AddGun, AddAmmo, AddToAmmoGroup, and UseAmmoGroup, are accumulated.
• Resource names are sanitized before use. Prefer lower-case names without spaces.
• Unless a table says otherwise, times are in ticks.
• ~ means unset, empty, or not configured.
• Vector keys read with readVector accept bracketed, parenthesized, or bare three-component vectors. Both [1,2,3] and [1 2 3] are valid; compact comma vectors and decimal commas are also accepted where unambiguous. Keys that explicitly say float float float use whitespace-separated values.

Concrete type files inherit every parameter from their parent type.

InfoType
|-- PaintableType
|   |-- AttachmentType
|   |-- GunType
|   `-- DriveableType
|       |-- VehicleType
|       |-- PlaneType
|       `-- MechaType
|-- ShootableType
|   |-- BulletType
|   `-- GrenadeType
|-- BlockType
|   |-- ArmorBoxType
|   `-- GunBoxType
|-- AAGunType
|-- ArmorType
|-- GloveType
|-- ItemHolderType
|-- MechaItemType
|-- PartType
|-- ToolType
|-- PlayerClass
|-- Team
|-- RewardBox
`-- LoadoutPool

Inherited by every concrete type.

Both maintained versions use the same .txt recipe generator and write both JSON layouts: data/<namespace>/recipes/ for 1.20.1 and data/<namespace>/recipe/ for 1.21.1. The compatibility layer writes legacy crafting outputs as result.item and smelting outputs as a string; modern outputs use result.id and a smelting result object with id. Modern crafting counts are limited to the output item's stack size; legacy counts preserve RecipeOutput. Loading an existing content pack fills missing counterparts without replacing authored recipes and regenerates definition-backed recipes when a generated layout is missing or the modern crafting count is invalid.

Inherited by AttachmentType, GunType, and the currently unregistered DriveableType.

Inherited by ArmorBoxType and GunBoxType.

Inherited by BulletType and GrenadeType.

Damage fallback after reading:

• If base Damage is absent, it is derived from the first available specific value in this order: living, vehicles, players, planes.
• Missing DamageVsLiving falls back to Damage.
• Missing DamageVsPlayer falls back to DamageVsLiving.
• Missing DamageVsVehicle falls back to Damage.
• Missing DamageVsPlane falls back to DamageVsVehicle.

The same damage inheritance rules used for direct-hit damage also apply to blast and frag damage groups.

These smoke keys are shared by bullets and grenades. A smoke shell should use a physical projectile (BulletSpeed or MuzzleVelocity) so its projectile entity can remain at the impact point for SmokeTime.

An ammo group is a named set of ammo items. It saves repeating the same ammo list in every gun, AA gun, and driveable that shares a calibre, and it lets a content pack extend an existing weapon's ammo selection without editing that weapon's definition.

A group has no definition file of its own. It is declared implicitly the first time a shootable type claims membership, and every later claim of the same name joins the same group:

// bullets/762x39_ball.txt
AddToAmmoGroup 762x39

// bullets/762x39_ap.txt
AddToAmmoGroup 762x39

Guns, AA guns, and driveables then pull the whole group in with UseAmmoGroup:

// guns/ak47.txt
UseAmmoGroup 762x39

Notes:

• Group names are case-insensitive and may contain spaces, for example UseAmmoGroup 7.62 x 39 mm. Trailing // comments are stripped, and repeated whitespace inside a name collapses to a single space.
• Group names are global: a group declared in one content pack can be used from another.
• Both keys are repeatable, so one ammo item may belong to several groups and one weapon may use several groups.
• Ammo pulled in from a group is merged with the weapon's own Ammo / AddAmmo entries and with any AddAmmoFor mappings. Duplicates are ignored, and the weapon's own entries keep their order and priority, so the default ammo of a weapon that lists both is still its first Ammo / AddAmmo entry.
• Driveables only accept BulletType members of a group; other shootables in the group are ignored there.
• UseAmmoGroup naming a group that no ammo item ever joined is reported in the log and contributes no ammo.
• A weapon can restate what a shared group member does out of its own barrel with the per-ammo statistic overrides below, instead of forking the ammo item.

Generic ammunition is deliberately shared. One 75mm AP Tank Shell item is loaded by a dozen different vehicles, and one belt is fed to several guns, so the ammunition item cannot describe every barrel that fires it. These keys let the firing weapon restate what a shared round does out of its own barrel, without splitting the content pack's item into a dozen near-duplicates.

They are read by GunType, AAGunType, and DriveableType, and they apply to ammunition reached through Ammo, AddAmmo, or UseAmmoGroup alike.

// vehicles/panther_g.txt — the shared 75 mm shell, fired from a KwK 42 L/70
AddAmmo 44_75APShell
AmmoMass              44_75APShell 6800
AmmoMuzzleVelocity    44_75APShell 935
AmmoExplosiveMassTNTg 44_75APShell 29
AmmoPenetrationAt100m 44_75APShell 188

The same item loaded by a Panzer IV would carry the KwK 40's 770 m/s and 143 mm instead, from that vehicle's own definition. Neither vehicle has to fork the shell item.

• The short name is the ammunition's own ShortName, as written in its definition, before any duplicate-resolution renaming. Matching is case-insensitive.
• Each ammunition is overridden strictly individually. Declaring a mass for one short name says nothing about any other ammunition the same weapon accepts.
• Resolution is against the weapon that actually fires the shot. A driveable firing a shell from its own bank uses the driveable's overrides. The same driveable firing through an AddGun / PilotGun mount uses that gun's overrides, because the gun is what declared the ammunition. Overrides never cascade from a driveable down into its mounted guns.
• Every key is repeatable, once per ammunition. A later line for the same key and the same ammunition replaces the earlier one; AddRoundForAmmo instead accumulates into that ammunition's replacement belt, in declaration order.
• AddRoundForAmmo replaces rather than appends. As soon as a weapon declares one round for an ammunition, that ammunition's own AddRound lines are ignored for this weapon. This is the opposite of AddRound, which accumulates.
• Values must be finite and non-negative. A malformed or negative value is reported as an ordinary content warning and dropped, leaving the ammunition's own value in place; it never aborts loading.
• An override may give a mass to a round that had none, which puts that round on the kinetic damage and penetration scale for this weapon only.
• Overrides are resolved from the weapon type at fire time and are never written into the projectile, so they survive world reloads and cost nothing in save data.

Per field, highest first:

1. the weapon's AmmoMass(Kg) / AmmoMuzzleVelocity / AmmoExplosiveMassTNTg(Kg) / AmmoPenetrationAt100m
2. the matching field of the weapon's AddRoundForAmmo belt
3. the matching field of the ammunition's own AddRound belt
4. the ammunition's own top-level value
5. for velocity only, the firing weapon's BulletSpeed, then the default bullet speed

A weapon may therefore override one field and leave the rest of the round untouched. The ammunition's BulletSpeedMultiplier still applies on top of an overridden velocity.

RemoveAmmo refuses ammunition a weapon would otherwise accept. It is read by GunType, AAGunType and DriveableType.

// A cruiser's 20.3 cm main battery, wrongly handed the ship's 2 cm AA shell
Ammo       ships_shell_german20cmhe
RemoveAmmo ships_shell_german20mmaa

• It is applied last, after Ammo, AddAmmo and every UseAmmoGroup, so it always takes precedence over all three. Order within the file does not matter.
• The short name is the ammunition's own ShortName, matched case-insensitively, exactly as for the per-ammo overrides above.
• The key is repeatable, and one line may name several rounds.
• Naming ammunition the weapon never accepted is harmless and silent.
• Use it to correct an obviously wrong inherited entry, or to deliberately narrow what a weapon accepts, without having to fork a shared ammunition group.

Inherits InfoType.

Inherits InfoType.

Inherits PaintableType and InfoType.

Inherits ShootableType and InfoType. Bullet files also reread Accuracy, Spread, and Dispersion using the same meanings as ShootableType.

A round with a tracer beam leaves a glowing 3D beam behind it every tick, drawn at full brightness and fading over 3 ticks, so the beams blend into one streak. Above 15 blocks per tick the beam grows with the square root of the speed, up to three times its length. Colours and alpha are fractions from 0 to 1. Beams are drawn by every client from the round's own state, so other players see them too.

A mixed belt makes every AlternateBulletLoad-th round fired from one ammunition item an alternate round, counted from the first round of the item, for guns, driveable weapons, AA guns and mechas alike. As in the Labjac Edition, alternate rounds exist only with HasAlternateModel true. They can use their own model, texture, beam and trail particles, and fall back to the ordinary ones for anything they do not set.

PenetrationAt100m is the separate, range-independent physical millimetre value used by vehicle armour. Penetration / PenetratingPower, decay, and block penetration remain legacy abstract-scale mechanics and are not converted to millimetres.

When the ammunition declares a projectile Mass, meaning it uses the kinetic damage system, penetrating power is derived from muzzle kinetic energy instead of from the authored Penetration / PenetratingPower:

penetratingPower = kineticPenetrationReference * cbrt(0.5 * massKg * muzzleVelocityMps^2)

AddRound belts derive it per round. See Penetration System for the resulting scale, the velocity resolution order, and what spends the budget.

Inherits ShootableType and InfoType.

Grenades use the same per-tick simplified projectile drag as bullets: velocity is retained at 0.99 in air, 0.8 in water, and 0.6 in lava, followed by gravity (9.81/400 blocks/tick squared times FallSpeed). Thrown guns use these same medium factors and the same 9.81/400 gravity.

Flash effects use the standard effect-line format and support multiple entries:

FlashEffects true
FlashDamageEnable true
FlashEffectsDuration 100
FlashEffectsLevel 0

FlashEffectsID 15
FlashEffectsID 2 200 1
AddFlashEffect 18 80 0

In this example, the first effect inherits duration 100 and amplifier 0. Values supplied on an individual line override those defaults. FlashEffectsID and AddFlashEffect behave identically.

Inherits PaintableType and InfoType.

Deployable guns keep the direction chosen at placement across world reloads. Their barrel can traverse within SideViewLimit while operated, then returns to the placed direction when unoccupied. They move an operator who mounts from the front to a clear position behind the gun. They cannot be mounted without room there. An obstruction to either side stops the operator from moving farther around the emplacement, while the weapon can continue traversing through its normal yaw range. A configured FlashModel or MuzzleFlashModel is drawn for two ticks at the deployed model's automatically measured muzzle and follows its yaw and pitch. The client's muzzleFlashStyle preference selects the model when both are declared. When that muzzle can be measured, projectiles start there and first-person view height follows the model with enough clearance to see over the weapon. Unmeasurable legacy models retain normal standing eye height and use PivotHeight for firing. The bundled conventional machine guns use consistent envelopes: bipod guns use 30 degrees up, 10 degrees down and at most 40 degrees to either side; tripod and heavy guns use 20 degrees vertically and at most 40 degrees to either side.

All keys in this subsection are read by GunAnimationConfig from gun type files on the client. Defaults are unset, meaning the model/default animation values are used.

Inherits BlockType and InfoType.

Inherits BlockType and InfoType.

Armor set lines after AddArmor use:

<armorShortName> [<item> <amount> ...]

The recipe parser uses item/amount pairs for those four armor lines.

Inherits InfoType.

RF engines are not eligible for automatic/default-engine selection, even when CanBeDefaultEngine is enabled.

Inherits InfoType.

Inherits InfoType.

Inherits InfoType.

ItemHolderType currently reads no additional parameters beyond the shared InfoType keys.

Inherits InfoType. Loaded from mechaItems.

Inherits InfoType. Loaded from classes for the Teams system.

The SkinOverride texture is read from the pack's skins folder and is only applied when its size matches a player skin layout, otherwise it is ignored with a warning in the log:

• A square sheet (64x64, or any whole multiple of it for HD skins) is used as it is.
• A 2:1 sheet (64x32, or any whole multiple of it) is read as the old skin format and rebuilt into the modern layout before use, the same way Minecraft treats old skins: the left arm and the left leg are filled with horizontally mirrored copies of the right ones, only the head keeps a second layer, and a hat layer painted fully opaque, which is how old editors wrote "no hat", is dropped.

Clients only draw the override when enablePlayerClassSkinOverrides is on, and never on players another mod renders with its own player renderer or model.

Inherits InfoType. Loaded from teams.

Inherits InfoType. Loaded from rewardBoxes.

Inherits InfoType. Loaded from loadouts for ranked Teams loadouts.

Extends PaintableType and inherits its parameters along with the shared InfoType parameters. It also reads driveable-specific parameters for seats, parts, weapons, movement, sounds, collision meshes, and particle emitters.

Driveables also accept optional real-world specification keys prefixed with Real, plus DriveType, and optional physical armour and normalized-health keys. These are documented separately on the Realistic Vehicle Physics and Vehicle Armour and Damage pages. They are entirely optional: a definition that declares none of them keeps its existing behavior exactly, and no legacy key listed on this page changed its meaning or unit.

These Krishna-compatible keys configure driver, pilot, and passenger gunsights. Sight indices are one-based. Camera positions use model units and are divided by 16. See Vehicle Optics for controls, rendering behavior, examples, and the HUD editor.

Optics HUD keys beginning with SeatOptics take a seat id immediately after the key. Sight variants then take a one-based sight id. The PilotOpticsHUD... forms apply to seat 0 and omit the seat id.

For each element family, Pos takes <x> <y>, Scale takes a positive float, Texture takes a texture or NONE, and TextureSize takes <width> <height>. The listed PosSight, ScaleSight, and TextureSight forms insert a one-based sight id for a per-sight override; texture size is global to the element.

Positions in these rows use legacy model units and are divided by 16 unless stated otherwise. Seat id 0 is the driver; passengers start at 1.

For planes and helicopters, a running engine and its selected throttle remain active while any seat is occupied. If the driver seat becomes empty while player passengers remain, the first occupied player passenger seat in definition order receives throttle, yaw, pitch, and roll control. Pilot weapon banks and auxiliary pilot controls are not delegated; the passenger's own authored gun remains independent. When the last rider leaves, the engine request and throttle are cleared.

Bomb banks release their projectiles at zero velocity relative to the driveable. A dropped bomb inherits the driveable's world velocity at release, then its configured gravity changes its motion. The bank's BulletSpeed adds no launch speed to a dropped bomb. Other weapon-bank types continue to use their resolved muzzle velocity and firing direction.

For example, this definition line gives a linear engine pitch curve:

EngineSoundPitchRange 1.0

With no EngineSoundPitchBase line, the default client base is 0.5. The pitch is 0.5 + throttle × 1.0: 0.5 at 0% forward throttle, 1.0 at 50%, and 1.5 at 100%. Here Range is the difference between the 0% and 100% pitches, not the 100% pitch itself. If you also set EngineSoundPitchAt50 0.8, only the 50% point changes; the 0% and 100% points remain 0.5 and 1.5.

Engine accepts a shortname or item ID with or without a namespace, such as advCPU, flansmod:advCPU, or otherpack:advCPU. Empty, missing, invalid, or incompatible values use the normal default-engine rules. The selected engine must still be eligible: an ENGINE part with CanBeDefaultEngine true, no RF power, and a matching WorksWith entry.

All keys are optional. Semantic armour uses nominal millimetres followed by an optional virtual slope in degrees. An explicit 0 thickness means intentionally unarmoured and remains distinct from an absent value. See Vehicle Armour and Damage for angle conventions, precedence, penetration, damage, and explosion behavior.

Naval semantic armour is resolved as a set of per-part overrides before explicit PartArmorMm lines are applied, so an explicit per-part line always wins.

All keys below are optional. A key present without a value counts as not specified. Invalid values are reported as content-pack errors and ignored; they never abort loading and never activate a subsystem. See Realistic Vehicle Physics for activation rules, precedence, and the speed scales.

Every Real… key in the tables below also accepts the same name without Real (for example, MassKg for RealMassKg). The Real… spelling takes priority if both are declared, including when its value is blank or invalid. These aliases are separate from legacy keys such as Mass, MaxSpeed, and WingArea.

Common, read on every driveable:

Aircraft, read on PlaneType: