Skip to content

Kiln 0.2.0-dev.28

Pre-release
Pre-release

Choose a tag to compare

@frostdev-ops frostdev-ops released this 14 Nov 23:25
2301cc5

Kiln 0.2.0-dev.28

OnBoot: a mod's content, and its changes to the game's own data, are in place before the game reads them, on the very first start. A boot mod can now raise the number of Flame Altars a base may have, or change the experience each level needs, and the game uses the new values from the first start. Also new: questions about the world and paths, terrain overlays, follow-up moves for weapons, tool wear, values in the game's own UI, block kinds of your own, creature control, update checks in the launcher, and kiln publish. Kiln mods keep working next to another loader that patched the game first. What only a real game can confirm ships switched off until the guided client pass confirms it.

Mod authors

  • The mod API is 0.2.3. Everything new is additive: no public member of 0.2.0-dev.27 was removed or changed.

OnBoot: content that is there on the first start

  • Set "boot": true in kiln.mod.json and stage statuses, effects, items, spells and talents in Mod.OnBoot with BootDefinitions.For(boot).Define(...). They exist before the game reads its data, on the very first start, with the same ids a runtime Define gives them. Mods.BootState(id) says whether a mod's boot content made it.
  • "boot": "required" makes a start stop with a clear message when that mod's boot content cannot be applied, instead of loading a world without it. A broken boot mod that is not required is left out and named in kiln.log; it never half-loads.
  • "required" covers the mod's own files too: one bad entry in its assets.json, blocks/*.json, skills/*.json or quests/*.json stops the start (exit code 0x4B01), and the last kiln.log line names the file, the entry and why. What only a loading world shows (a skill node the tree build leaves out, an item, recipe or clone the world does not register) stops the start while that world loads, before a player is in it. Without "required" such an entry is logged and left out, as before.
  • Blocks.Find finds a block your OnBoot staged as soon as the boot generation commits: in OnLoad, by name from other blocks, and after an unload. Defining the same block again returns the committed one; a different block under that name is refused with RestartRequiredBoot.
  • A boot mod whose files (anything in its folder but what Kiln writes there) or whose settings read in OnBoot changed since the start is refused when it is loaded again, with RestartRequiredBoot naming the files or the setting (coldSeconds: 4 -> 5): restart the game or the server. Reformatting a JSON file, or Kiln rewriting the settings file, is not a change. Reading a boot mod's files costs about 1 s per 300 MB at the start.
  • KilnHarness.BootPhase in Kiln.TestKit runs a mod's OnBoot under dotnet test, with the same staging as a start, and the SDK's bake runs it too: a build fails (KILN032) when OnBoot throws or a definition would not lower. Sample: boot-gallery.
  • Only those five kinds of block can be staged at boot in this release; the others answer NotInBootKinds and still work as runtime blocks in OnLoad.
  • On a game client (a world a player hosts, and a player's game that joins a server) OnBoot is switched off until its game test (mods.boot.client): a mod with "boot" does not load there, and a game with an enabled "boot": "required" mod does not start (exit code 0x4B01, the reason is the last line of kiln.log). A dedicated server has OnBoot. Do not ship "required" to players yet; "preview" in kiln.json switches OnBoot on for testing.

Resource patches: the game's own data, changed before it is read

  • A boot mod can change fields of the game's data before the game reads them, for example the balancing table's experience per level or Flame Altars per flame level. Use resourcePatches in a blocks file or a ResourcePatchBlock in OnBoot; paths take [*] for every element, and values take a number or mul, add, min (at least) or max (at most). Numbers, bools and enums only. resource-patches.md
  • A change made in OnLoad came too late for such data: the game had already read it. A patch is checked before the start and written when the game's resource service is up and nothing has read from it yet.
  • resourcePatches in a blocks file may have comments and trailing commas, as every other blocks file may.
  • Both sides need the mod. When a required boot mod's patch cannot be applied, the start stops with the reason in boot.json instead of loading a world without it.
  • IReadOnlyGameData in OnBoot reads the game's own data (items, templates, skills, materials) from the boot snapshot (boot-gamedata.md). Kiln makes the snapshot from the game's files at Play when an enabled mod boots: about 30-45 s and 200 MB once per game update.
  • On a game client mods.boot.resource_patches is switched off until its game test, as OnBoot itself is (above); a dedicated server has it.

Update checks for your mod

  • Name your GitHub repository in updates in kiln.mod.json, and players get update notices in the launcher and from kiln updates check. A release made with kiln publish carries everything the check needs. updates.md
  • A value Kiln cannot read in updates is a warning and is ignored; it never stops your mod loading.

Settings in OnBoot

  • Config.Register<T>() and its Value work in OnBoot: a boot mod can stage with a number from its settings (a level cap, an altar count). Writing a setting, Reload and Changed are for OnLoad; in OnBoot they say so.
  • A call that needs the game's tick says, in OnBoot, which member refused and that it belongs in OnLoad.
  • ConfigFile.TrySet returns false, with "cannot write" and the reason, when the settings file cannot be written, and changes nothing then; before, it returned true. Set and Save behave as before. The new ConfigFile.LastWriteError says why the last write failed and is null after one that succeeded.
  • Kiln.Sdk: <KilnBoot>true</KilnBoot> (or required) writes "boot" into the generated kiln.mod.json, and that alone opts the mod in (no KILN034 for a project without its own kiln.mod.json).
  • KILN035 does not warn about Config.Register<T>() and .Value in OnBoot; it warns about writing a setting, Reload, RegisterWorld and adding a Changed handler there.

Publishing a mod

  • kiln publish releases a packed mod as a GitHub release in two steps: a plan you read (the zip is checked for game data, cooked files, saves and secrets, then frozen) and an apply you confirm, which makes a draft with the zip, its checksum and a kiln-release.json. A third step makes the draft public. A run that stopped resumes without uploading anything twice. publishing.md has the whole of it.
  • The token is read from your system's credential store (kiln publish --store-token github puts it there, read from standard input). Where there is no store, a CI job for example, it is read from the environment variable KILN_PUBLISH_GITHUB_TOKEN. It is never written to the plan, the journal, a log or an error.
  • Not yet tested against GitHub itself, only against recorded answers: make your first release to a repository you can delete ("The first real run" in the guide).
  • An uploaded file whose answer carries no checksum is downloaded once (bounded) and hashed before --resolve-step adopts it, and the journal is written through to disk before each step on Unix and Windows.

Questions about the world

  • Kiln.Queries answers on the server: the first terrain or building voxel on a segment (RaycastVoxels), the ground below a point (GroundBelow), voxel line of sight between two entities (VoxelLineOfSight), and the entities whose origin is inside a sphere or a box. queries.md
  • An answer is a hit, a miss or "unknown" (the terrain there is not loaded): a ray never reports open space it could not read.
  • Voxel rays do not see props or creatures. All mods together share 64 rays and 500 microseconds of ray time in a server step; a call beyond that answers BudgetExceeded, which means "next step".
  • A creature brain can ask for line of sight: Perception = new NpcPerceptionPolicy { Occlusion = NpcOcclusionMode.Voxels }, or "perception": { "occlusion": "voxels" } in a block file. What is behind terrain or a building is then not in Seen, and what could not be checked is not seen either. npc.PerceptionStats says why. npc-blocks.md
  • Kiln.TestKit has a fake for the queries (kiln.Queries): this code runs under dotnet test.

Paths

  • Queries.FindPath asks the game's own path search, the one its creatures use, for a walking route between two points at most 200 m apart; Queries.CanReach asks only whether one arrives. The answer comes some server steps later and is a copy of the route's points from the step the game answered. queries.md
  • Nothing is moved: a brain walks the points itself, one after another with MoveTo. MoveTo alone is not pathfinding; it walks straight at a point.
  • A request names an anchor entity with the game's spawn marker; for a player or a saved entity, spawn a helper pickup and use that (the guide says how). At most 32 requests are open at once, 8 for one mod; a request ends after 10 s and 150 steps.
  • On a world a player hosts, queries.path and queries.reachability are switched off until their game test (02-queries.path-hosted). A dedicated server has them.

Game types, content blobs, scale

  • GameType.ImpactName, GameTypes.ByImpactName and FindAllByImpactName find a game type by the name Impact scripts use (ecs.Health). Capability types.impact_names.
  • Assets.OpenBlobCatalog lists every content blob the game serves, the game's own and every mod's, with where each comes from and whose bytes are served. Capability assets.blob_catalog; sample BlobCatalog.
  • World.SetTransformScale sets an entity's scale for each axis as one tracked write. It changes the drawn size, not collision. It survives a save and a restart: the game's save does not keep a scale, so Kiln keeps it beside the save and sets it again in your mod's name when the entity loads, while your mod is loaded (EntityScaleResult.Persisted says whether it comes back; entities the save does not keep stay session-only). The row is decided by the time OnLoad runs. Capability world.transform_scale, switched off until its game test (13-world.transform-scale), on a server as well; sample TransformScale.

Terrain overlays

  • Kiln.Terrain puts a bounded patch of ground into the world: an ore vein, a mound, a tunnel, a small dungeon shell, as a C# record (TerrainPatch) or JSON. Terrain.Apply writes it once per world, a batch each tick, and remembers which mod owns it and at which version. terrain.md has the whole of it, the sample OreVein an ore vein.
  • The cells are ordinary world edits: the game saves them and sends them to every player, also to a player without Kiln. A version of a patch never writes over ground a player changed since the last one; Terrain.Inspect says what Apply would do and writes nothing.
  • Game materials only: a player without the mod has no look for a material of a mod's own, so a patch refuses one.
  • On a world a player hosts, terrain.overlays is switched off until its game test (19f-overlay-client). A dedicated server has it.
  • Removing a mod leaves its ground where it is (Terrain.Forget only drops the record). Two mods' patches are kept apart only while both are installed.
  • Kiln keeps a second record of each world's kept plans (kiln/data/kiln.terrain), so it tells a lost ledger from a first install: a plan whose world lost its Kiln data is refused ("ownership lost"), and a first install over ground that already looks like the plan is accepted. Apply writes nothing when that record cannot be written.
  • BuildFlags.Transient and TerrainPersistence.Transient edits are gone after the next restart, also inside a player base or next to a kept edit: Kiln journals them before each save and puts back what was there at the next start (a cell changed since keeps that change). Transient together with Unloaded is refused, and so is a transient write while the world's identity is unknown.
  • Kiln.TestKit's terrain world models both: KilnHarness.Terrain.SaveWorld, LoseLedger, Witnessed and Restart.
  • Build.WriteIfUnchanged writes only if the world still holds the cells you read when the write commits, after every BuildEditingEvent handler; otherwise it returns BuildRefusal.Changed and writes nothing. Terrain overlays write this way: a change another mod makes to the same spot while an overlay is applied is kept, and the overlay gives up that block.

Weapon moves: follow-ups

  • A weapon's move can say where its follow-up windows lead. MoveBlock.FollowUps points a window the motion already has (Primary, Heavy, Block, Parried) at another move of the same weapon: a block that goes on into the weapon's own parry, for example.
  • A weapon with follow-ups gets all its moves or none of them. Blocks.MovesStatus says which (MoveApplicationResult), and WeaponMovesApplicationChangedEvent says when that changes; unloading the mod takes the moves off again.
  • A weapon's moves are written in one content transaction: if any part fails, all of it is taken back and read back, also when they are written again after a world or pack reload (Refused with the reason in Blocks.MovesStatus). If the take-back cannot be verified, Kiln takes every change of that mod off and the status says so; its other weapons are planned again.
  • Native plugins: KilnContentApi has txn_begin and txn_end appended (check header.size): an owner's field writes taken back whole and read back, or the owner revoked.
  • blocks.move_followups is switched off until its game test (16c-b, 16c-d), on a server as well: what decides is what a player sees. "preview" in kiln.json switches it on.

Network

  • When the game's own refusal of a player fails, Kiln falls back to the game's admin kick (capability net.disconnect, dedicated servers), so a refused player never stays connected half-way.
  • NetPeer.FramesIn and NetPeer.FramesOut count the frames each player's game and the server have sent on Kiln's channel.
  • Kiln's own services can now hold a joining player with Kiln at the door, before the world is theirs: at most 25 s, with frames flowing both ways while they wait, and then let them in or refuse them with a reason. Capabilities net.admission and net.gate.hold_all. Mods use this through the services built on it in later releases, not directly.

Tool wear

  • ToolBlock.WearPerDebit and Items.SetToolWearPerDebit(tool, n) make each of the game's wear debits of an axe or pickaxe cost n instead of 1 (0 to 32767). It counts per debit, not per swing: two debits spend twice, and a swing the game does not debit spends nothing. Rules last while the game runs and go with their mod. Items.ToolWearStatus, ToolWearRuleChangedEvent and ToolDurabilityChangedEvent say what is in effect and what changed. ToolWearRuleChangedEvent comes once for every change, in order, also for rules a native plugin sets or removes and rules that go when a plugin unloads; native plugins read the same changes with kiln.toolwear's rule_changes.
  • On a world a player hosts it is switched off until its game test (16b-g); a dedicated server has it.

Values in the game's own UI

  • Client mods can replace the numbers and bars the game draws for an item (the detail view, an inventory slot, the held item) and the local player's health, stamina and mana with Ui.Values. It changes the picture only, never the values themselves. They can add lines to Kiln's Item details window and read the slots the game drew each frame.
  • Every part of it is switched off until its game test (05a-c1 to 05a-c5).

Block kinds of your own

  • A mod can add a kind of block of its own (Blocks.RegisterKind): other mods then write that block in C# or in blocks/*.json, and Kiln turns it into its own items, weapons, spells, statuses and effects. A block that is refused part way leaves nothing behind.
  • A plan with parts that wait for content ready (every item plan has some) stays PendingContent, with nothing published, until those parts are done; then it is Applied. A part that fails refuses the plan with ContentReadyFailed and its reason, and what it registered is taken back.
  • When the game applies its content again (a pack reload, a mod reload, a new world), an applied plan is lowered again from what it froze, without asking the provider, and gets a new Generation; a failure then refuses it and takes back what it registered (RelowerFailed, ContentReadyFailed).
  • A plan is refused, with the reason, when its effects would expand to more than 4096 effects or 16 MB of programs, or nest more than 32 named effects deep. A block of an external kind is read strictly into the provider's record type; SchemaJson is for editors and is not checked by Kiln.
  • Kiln.Blocks reports its capability rows at its first use: in OnLoad, before the first call into Blocks, Capabilities.Is("blocks.…") still answers false. Use the call itself and its KilnUnavailableException.

Creature control

  • Kiln.CreatureControl (server) lets a mod take a lease on a creature: while the lease drives, the game's AI is off and the steering that overwrote movement input is removed; both come back on release. Roles decide who wins, and a refusal comes back as a result with its reason. Sample: CreatureControlSample (/hold, /pacer).
  • A body the broker cannot give back is removed, and if the broker itself stops, every body it holds is removed at the next step. Since this release that includes creatures run by a mod's brain.
  • Sample NpcSample now has a brain that walks a path found with Queries.FindPath.

Key bindings

  • Every key has a name that reads back at the next start: a key with no name of its own is saved as Key and its code (Key223), and the OEM keys have names (Oem8, IntlBackslash and the others). Punctuation names such as Backquote mean the key at that place on any keyboard layout, so a default of Backquote is the key left of 1 on UK, German and French keyboards too. A keybinds.json of 0.2.0-dev.27 loads. Its bindings fire on the same keys on a US layout, and everywhere for keys that are not punctuation; on another layout a binding saved under a punctuation name (a UK ' key was saved as Backquote) now means the key at that name's US place, so set it again in Kiln > Keys if it moved.

NoClip

  • PlayerNoClipEndedEvent has a new reason, NoClipEnd.Left: the player left or their world closed while in NoClip. When they are next in the world inside the ground, Kiln puts them at their last free position (RestoredTo).

Test kit

  • kiln.Capabilities.Override(name, false) also switches off rows a Kiln service builds from others (queries.ground), and rows built on a switched row follow it at once. A harness no longer sees capability rows left over from an earlier test.
  • When one of the kit's fakes throws while a harness is disposed, the harness still cleans up and the next one can start; Dispose then throws that error.

EMF mods

  • kiln-emf serves EmfApi v42 (EMF 0.6.11). EMF 0.6.10 and 0.6.11 added no function, only two fields (EmfMoveOrder.stuck_seconds with the flag EMF_MOVE_PEACEFUL_ALL, and EmfPathResult.doors), so a mod whose mod.json says "emf": 41 or 42 now loads instead of being refused, and emf::has_v41() and has_v42() answer true. enemy_move and path_find, the functions those fields belong to, still answer "not available on Kiln yet". Docs: emf.md.

Capabilities that wait for their game test

  • Some of what this release builds can only be confirmed in a real game, and ships switched off until it has been. Such a capability reads unavailable with the reason policy and the text game test pending: followed by the guided checks that open it. Capabilities.IsHeld(name) and Capability.IsHeld tell "built, not tested yet" from "does not work here".
  • "preview" in kiln.json switches held capabilities on before then: true for all of them, or a list of names ("preview": ["camera.fov"]). Use it on a test server or in your own game, not on a server other people play on.

Groundwork

These parts of later packages are in this release but promise no feature yet; mods should not build on them. Their public types are marked experimental (KILNX001 or KILNX028: a mod that uses one has to opt in with NoWarn).

  • The game's ECS programs by name, native wraps and the lab switch that forces programs onto worker threads (06a).
  • Typed links in kiln.hooks: a hook's signature checked against the game's code at load (06b).
  • An observer of owners being retired, for native services (03).
  • kiln.repl and the lab's loopback harness with fake players (11).
  • The shared contract of capacity budgets (17b, KILNX028).

Players

  • The launcher can tell you when a mod has a newer version: press Check for updates above your mods, or switch on "Check for mod updates once a day" in Settings (off by default). A notice is only a link to the mod's page; nothing is downloaded, installed or switched for you. A mod's menu has Updates…, where you see what the last check said or tell Kiln where a mod is published.

  • Mods can show their own numbers and bars in the game's item details, slots and HUD, once those parts pass their game test.

  • Mods that add items, spells or talents can have them ready on a server's first start, with no second restart.

  • Mods can make an axe or pickaxe wear faster, slower or not at all on dedicated servers; hosted worlds follow after the game test.

  • Mods that change values the game reads once at its start (experience per level, how many Flame Altars a base may have) now work from the first start on a dedicated server, and on a world you host once its game test has passed; before, their change came too late.

  • A server may keep you on the loading screen a little longer while its mods check your game; after at most 25 s you either join or get a message saying why not.

  • Mods can now add small landforms and ore veins that stay after a restart, and that you see without any mod of your own when you join a server that has them.

  • EMF mods made for EMF 0.6.9 to 0.6.11 start on Kiln, also those that ask for EMF 0.6.10's or 0.6.11's API.

  • NoClip and character flight: holding sneak always sinks and letting go stops, also in the game's sneak mode (GitHub issue #25). A player who leaves a server, or whose world closes, while inside the ground in NoClip is put back at their last free position when they return.

  • A key you set in Kiln > Keys that showed as Key223 (or another Key number) is no longer lost at the next start, and mod keys on punctuation keys work on non-US keyboard layouts (GitHub issue #33). The round-trip fix is by bisdat (pull request 34).

  • Props a mod has resized keep their size after the server restarts.

  • Temporary terrain from mods no longer stays in your save when it was made inside a base.

  • Temporary terrain a mod makes in a new world, opened after another one in the same game session, is no longer recorded under the earlier world.

  • If you copied an EML mod into ShroudForge's mods folder yourself and ShroudForge keeps it switched off, Kiln now says so plainly and how to switch it on; the launcher's list of mods in the game folder no longer says such a mod loads.

Server operators

  • kiln/config/kiln.queries.json sets how many voxel rays all mods together may cast in a server step and how much time they may take (64 rays and 500 microseconds unless you change it). It is read once, at the start.
  • A server with a required boot mod no longer starts with part of that mod missing: it stops with exit code 0x4B01, and the last kiln.log line says which file of which mod to fix.
  • Keep kiln/data in your backups: it holds the terrain records that stop a terrain mod from rebuilding its ground over your players' changes (kiln/data/kiln.terrain), the journal of temporary edits (kiln/data/kiln.build/transient), and the scales mods set on props (the world's folder, entity/kiln:world). If you remove the mod that set a scale, those props go back to normal size.

Fixed

  • Kiln mods no longer stop working when another loader has changed the game's code in place before Kiln starts: Flame's Creative Mode 3.2.0 and Greeneye's The Worst Map Mod switched off up to 22 of Kiln's features that way (moving items, chat, mod screens, player rules), so mods that showed as loaded did nothing. Kiln now reads the game's functions from the exe file in that case and says in kiln.log which places another mod patched. Not yet seen in a player's game: the guided check 00-sigdb.in-place-patches (Creative Mode 3.2.0 with Multi Planter) confirms it.
  • A creature driven by a mod's own brain (Brain = () => new MyBrain(), or "brain" in a block file) now walks. Before, the game's own steering overwrote MoveTo and the creature stood still. Kiln.Blocks now takes the body from the game's AI while the brain runs (MoveTo, Stop and Face act only while it has it) and gives it back when the brain stops or its mod unloads.

Built, game test pending

What this release carries switched off because only a real game can confirm it. Each entry names the capability and
the guided checks that open it; "preview" in kiln.json switches one on by name before then.

  • assets.blob_catalog (on a game client; a dedicated server has it): Client asset catalog acceptance (13-assets.catalog-client)

  • blocks.move_followups: Follow-ups: a block hands over to the weapon's own parry and light attack (16c-b); Follow-ups: held block, parry timing and shield recovery (16c-d)

  • items.tool_wear_debit (on a game client; a dedicated server has it): Tool wear: a pickaxe worn 7 per debit, and its durability bar (16b-g)

  • mods.boot.client (on a game client; a dedicated server has it): First-start content and rehosting (08-boot.first-start-definitions); Other-loader consumer ordering (08-loader-order)

  • mods.boot.resource_patches (on a game client; a dedicated server has it): First-start content and rehosting (08-boot.first-start-definitions)

  • mods.boot.vfx (on a game client; a dedicated server has it): First-start content and rehosting (08-boot.first-start-definitions)

  • queries.ground (on a game client; a dedicated server has it): Ground, wall and query-only safety (01-queries.voxel-ray-hosted)

  • queries.line_of_sight (on a game client; a dedicated server has it): Ground, wall and query-only safety (01-queries.voxel-ray-hosted)

  • queries.overlap_origins (on a game client; a dedicated server has it): Ground, wall and query-only safety (01-queries.voxel-ray-hosted)

  • queries.path (on a game client; a dedicated server has it): Paths around a wall, cleaned up, and again after a reload (02-queries.path-hosted)

  • queries.reachability (on a game client; a dedicated server has it): Paths around a wall, cleaned up, and again after a reload (02-queries.path-hosted)

  • queries.voxel_ray (on a game client; a dedicated server has it): Ground, wall and query-only safety (01-queries.voxel-ray-hosted)

  • terrain.overlays (on a game client; a dedicated server has it): A terrain overlay as a hosting and a joined player sees it (19f-overlay-client)

  • ui.slots.inspect (on a game client; a dedicated server has it): Cursor, gamepad, geometry and chest transfer (05a-c5)

  • ui.values.detail (on a game client; a dedicated server has it): Detail numbers and slot bars (05a-c1)

  • ui.values.held (on a game client; a dedicated server has it): Nonzero held water and visible stamina identity (05a-c3)

  • ui.values.hud (on a game client; a dedicated server has it): Retained post-update HUD writes (05a-c2)

  • ui.values.slot (on a game client; a dedicated server has it): Detail numbers and slot bars (05a-c1)

  • ui.values.tooltip_lines (on a game client; a dedicated server has it): Replacement owned details viewer (05a-c4-viewer)

  • world.transform_scale: Rendered scale versus collision and save (13-world.transform-scale)

  • The start bar no longer sticks at "Starting" while the launcher makes the game data for OnBoot mods (once per game update, about a minute): that is a step of its own now, with its progress and in the time left.

  • Moving the data folder, or using an existing one, could now and then be refused with "Another Kiln Launcher is using the data folder" right after another step, while the launcher was starting a program; it no longer is. The launcher's other locks release the same way.

  • Update checks order very long numeric prerelease versions by value (dev.10000000000 is newer than dev.9999999999), in the launcher, kiln-manage and the native loader alike.

  • Play once (a single start of a mod set with another profile) makes the boot snapshot too, so an OnBoot mod that reads the game's data finds it ready.

  • kiln lint reads the schemas' lookbehind patterns as the editors do; it rejected every value of the publish tag and two folder-name fields before.

  • Kiln recognises the relays other hook engines use (greeneye plugins, XHL mods: an indirect jump at any offset, a pointer table, a jump to a relay) as hooks, so it keeps reading the game's code from the exe file beside them. If it has to read the live code instead, it no longer trusts captures read through calls another engine redirected, and kiln.log names the first difference it did not recognise. By rifters (pull request 31).

Known limits

  • OnBoot, "required", on a game client: a required mod with VFX or materials, or with a texture override, stops the start when that part cannot be built or applied; this is proven only by its guided check (08-boot.required-client). A dedicated server builds no VFX (each player's game does), so that never stops a server.
  • OnBoot on a server with players: a game client does not load boot mods until mods.boot.client passes its game test, so a dedicated server running a boot mod its players need ("clients": "mod", for example a mod that raises the Flame Altar limit with a resource patch) refuses Kiln players until then. A player can join with "preview": ["mods.boot.client", "mods.boot.resource_patches"] in kiln.json, or the server can set modSync to warn; then the player's game keeps the game's own values for what the mod patches.
  • Terrain overlays: if all of kiln/data is lost, or a world is moved without it, a plan with no record is a first install again.
  • NoClip: a player who is still connecting when they are put back may fall a few steps inside the rock first, until their game confirms the collision hook.
  • Weapon follow-ups: when a failed take-back cannot be verified, every change of that mod is taken off, not only the weapon's; its other weapons and rules come back at the next content pass.