qc_common

Status samples of the admin channel over time (decisions E-848, E-863)

Advancements in the content sync (QcContentSerializer, decision E-923): everything the client shows (tree, icon, texts, frame, handbook link) and the names and requirement groups of the criteria; the triggers and conditions stay on the server (the client gets Impossible)

Resolves the anvil swaps of all blocks once all packs are loaded (decision E-870): a block's anvilSwap gives its item the swap into into and the item into the swap back, both paid with one with

Parses the "armour" object of an item (decision E-235): slot, points, set, layer boxes and parts

Loads the base game content pack (embedded as :/content/qtcraft) into a new registry

Parses block definitions of content packs

Wire format of one block definition in the content sync, with its resolved shape

Body of a boat (decision E-920), the same for the server (collisions, riders, placing) and the client (targeting, drawing, the driver's prediction)

Where a body fits into the world: clear of the collision boxes of the blocks around it

What build and machine a log, crash report or login comes from (decision E-834): the project version and the git commit at configure time (CMake writes both into QcBuildInfo.cpp), the compiler, Qt, the operating system and the processor

Parses the coastal towers of the terrain ("coastalTowers" in worldgen/terrain.json, decision E-605); the structures and the foundation block are checked by the generator

Parses command macros (commands/*.json, decision E-248)

Content names have the form "namespace:path" with lowercase letters, digits, '_', '-', '.' and '/'

Parses the cooking fields of a block: "machine" (furnaces, smokers, blast furnaces; decision E-770), "campfire" (decision E-772) and "bites" (cake, decision E-773)

Crash reports (decision E-834)

Day and night as a pure function of world time (seconds)

Parses a kind of status effect (effects/<name>.json, decision E-450)

Enchanting table's rules as in the reference game (decision E-864): bookshelves around the table raise the three offers' levels, and a player's enchantment seed fixes the offers until he enchants (then the server draws a new seed)

Enchantments in the content sync (QcContentSerializer, decision E-864): every field, so the client knows effects and names

Parses the farming fields of blocks (decisions E-289 and E-290): "crop" (stages, pace, light, fruit of stems) and "soil" (moisture, water reach, what it reverts to)

Versions of the world generator (decision E-922)

Handbook tables built from the block data (category "tables", after the tables of QcHandbookOverviewPages, in this order): the Signal Dust components with what they take and give, the blocks that are no opaque full cubes with their light and spawning behaviour, the light sources and the blast resistance of every block (decision E-685)

Handbook chapters about playing (category "playing"), in content order: their sections with rule and key placeholders filled, and links to related content

Handbook pages of the items without a block page (categories "items", "tools" and "food"), in content order

Markdown export of a handbook: index.md and one file per non-empty category, with relative links between entries

Data of the web handbook (web/handbook/data, shown by web/handbook/handbook.js like the handbook screen of the game): one JSON file per language with the packs, the categories with their entries in list order and every page in the form of QcHandbookJson::entry, each with the English title the search compares (QcHandbook::search)

Parses the "hangs" object of an item (decision E-790): "type" ("item_frame" or "painting"), for a painting its "motifs" ({"name", "texture", "width", "height"}, sizes 1 to 4) and its "back" texture

Parses how items are held (decision E-831): the hold object of an item or block and the category defaults in held.json

Parses item definitions of content packs

Coordinates of the cells of the light engine (QcLightEngine): the chunk and the place in it of a block coordinate, the index of a cell column in a chunk, the faces that lead to the neighbour columns

Parses the "flow" object of a liquid block: how far and how fast it spreads, whether it makes new sources, its bucket, bottle and sound, and its reactions with other liquids

Few cryptographic steps of the minimal login (decision E-252), all HMAC-SHA256 from QtCore: a password key stretched with PBKDF2, a player identity per server derived from the player's installation key, proofs bound to the nonce of one connection and a short fingerprint of an identity

Maps in the crafting grid (decision E-804), besides their recipes: a filled map with empty maps of its kind and nothing else copies it (one copy per empty map, all with its map id); a filled map in the middle of the 3 x 3 grid with its zoomsWith item in the eight cells around it zooms it out (a new map one scale larger, which the server makes when the result is taken)

Parses materials and the part families that turn them into building parts

Body of a minecart (decision E-382), the same for the server (collisions, pistons, riders) and the client (targeting, drawing, the rider's view)

Parses mobs and the skeleton models and appearances that characters are drawn with

Checks the traits of creatures (decision E-460) when the content is finished

Bounds of the admin messages, checked by the decoders

Access lists of secret files on Windows (decision E-901), where Qt's permission bits only set the read-only attribute: a file inherits the access list of its folder unless it gets its own

Registry function behind building parts: for every material of the registry and every part family of the material's kind, it registers the part's block (item follows from createBlockItems), its crafting recipe and its display names

Random key of one installation (decision E-252): 32 bytes, made on first use and kept as hex in <data>/player.key, readable only by the user

Box and the eyes of a body in each pose

Server's check of a player's profile before it takes it over (Hello, SetAppearance; decisions E-036, E-231, E-232): the client stores and sends the profile, but nothing it sends is trusted

Binary wire format: every frame is [quint16 type tag][payload] in QDataStream big-endian encoding

Where a shift-clicked stack goes, by its slot (numbers as in QcMsg::MoveInventoryItem)

Rails (decision E-382): the track a rail state lays out and the state a rail takes from the rails around it

Parses crafting and smelting recipes of content packs

Files that hold secrets (the player key, the server's TLS key, the known servers, a server's settings and identities; decisions E-252, E-872, E-901): written atomically (QSaveFile) and readable only by the user

Parses the showcase settings (worldgen/showcase.json, decision E-220)

Checks the links between Signal Dust blocks once all packs are loaded (decision E-333): a piston's head must be a piston_head block with the piston's facing values and sticky; a torch's or lamp's counterpart must exist, be of the same kind, have the opposite active and the same properties

Light of the open sky in a chunk (for QcLightEngine): the top of each cell column (the highest block that stops sky light), the cells above the tops that the open sky lights, and the cells beside a higher neighbouring column from which the light spreads sideways

Names of the sounds the game plays for blocks, creatures and the player

Where creatures that walk may appear by themselves (decision E-836), the same for every kind instead of a block list per creature: the ground is a solid block whose top face is full and that is drawn opaque (no glass, leaves or ice, no lower slab, path or farmland; an upper slab and a double slab carry), and neither ground nor the cells of feet and head hurt or hold a body (QcBlockDefinition::keepsSpawnsAway)

Corners of stairs as in the reference (decision E-754)

Bounds for counts read from untrusted streams (network, save files), so corrupt input cannot trigger huge allocations

Parses where the world generator places a structure by itself and what guards it (decisions E-590, E-591): groundLayer, surface (biomes, region spacing, chance, attempts, slope, margin to villages, foundation), guardians (zones whose creatures come back) and spawnArea (the monsters of its footprint, decision E-871)

Number of the tick phases and their ids

Parses the fields of the vegetation object of a biome (decision E-814): grass and flowers, each with density, patchSize, plants (block names or objects with block and weight) and patches (chance, tries, radius)

Street plans of a village style (decision E-408): layouts in villages/*.json, a list of weighted kinds with their parameters, and the defaults of each kind and of a style without the field

Outfits villagers wear (decision E-411): for every look (the default one of each villager species and each style's) and every profession with layers, the look's outfit with the profession's layers laid over it (an apron over the style's shirt), registered as a creature outfit under outfitName()

Names of the weather kinds and the climate of a column

Dimensions of the world

Parses the settings of the flat and void world types (worldgen/flat.json, worldgen/void.json, decision E-223)

Axis-aligned bounding box in world space (metres)

What an event must show for a criterion to be met; empty fields accept anything

An advancement of the adventure guide (advancements/<name>.json, decision E-923): its place in the tree (parent, empty for a root), how it shows (icon item, title and description keys, frame, hidden until reached, announced in the chat), the handbook entry it leads to ("chapter:<name>", "item:<name>", "block:<name>", "mob:<name>", "biome:<name>"), its criteria and which of them it needs: requirements holds groups, every group must have one met criterion

Allow-lists of adventure mode (decision E-735), a setting of the world: for each item kind, the blocks it may break and the blocks it may act on (be placed on, till, light, pour, …), like the reference's can_break and can_place_on, but per item kind instead of per stack

Air of a player or a creature under water (decision E-955), counted in game ticks

A player's chosen look: outfit, hair style and cape by content name, and four colours as 0xRRGGBB

Texture for one slot of a model

How a creature with the archer AI shoots (decision E-426), from its data (archer)

A layer box of a piece of armour (decision E-235): every box of the reference model (the humanoid) whose slot is in covers, made inflate metres larger on every side and cut to the heights fromY..toY (model space), drawn with texture on its bone

What the client draws and plays (part of QcContentRegistry, synchronised with the content): textures, skeleton models, appearances (outfits, hair styles) and sounds, each replaced by name

A biome of the terrain generator: its climate point, the shape of its land, its ground blocks, rivers, deltas, villages, monsters, features and vegetation (a biome file of a pack)

How a block takes part in explosions (decision E-600)

A box of block cells from low to high, both corners inclusive (decision E-975)

Integer position of a block in the world, in blocks (= metres)

What the player aims at when placing a block: face of the block at clicked, hit (0..1 inside that block), while looking along yaw and pitch (degrees, positive is up)

Everything that depends on one concrete block state, derived from the block definition and its shape

Textures of a block: one per face plus the named slots that shape parts use

A boat as it moves (decision E-920), the shared physics of the server (every boat, authoritative) and the client (the prediction of the own boat): its feet, velocity and contact (motion.inWater: it floats), the direction it points to and how fast it turns

A body as the push sees it

A campfire (decision E-772)

A creature that takes single blocks and puts them down again (the shadewalker, decision E-460), from its data (carries): only the blocks of blocks, and only while the game rule mobGriefing is on

Horizontal position of a chunk column, in chunks

Coastal towers of the terrain generator ("coastalTowers" in worldgen/terrain.json, decision E-605): a tower from structure data on land at or a little above sea level with ocean near it, standing on a foundation down to the ground

A command made of other commands, defined in data (commands/*.json, decision E-248): mods have no C++ access, so this is how they add commands

One word of a form: a literal or a placeholder

Manifest of a content pack (base game or mod): pack.json in the pack directory

Central catalogue of all content (blocks, items, creatures, recipes, effects); assets, world generation, villages and translations are catalogues of their own that it owns (decision E-715)

Wire format of the content sync message: everything a client needs to show the world

Every item of the content, mods included, sorted into the tabs of the creative inventory and searchable by name (decision E-286)

A creature that crumbles into blocks where it touches a source block of the liquid liquid (the sand golem, decision E-593), from its data (crumbles): it is gone without loot or experience, and its build stands in its place, an iron golem's T in reverse: body at its feet, in the middle above them and on both sides of the middle across its facing, head on the middle

Command line options of logging, crash reports and the health line, shared by qtcraft and qtcraft-headless

What the session starts with

Drunk with the use button like food is eaten (milk, decision E-500); it becomes emptiesTo

Dungeons of the terrain generator ("dungeons" in worldgen/terrain.json, decision E-522): a room of wall/moss blocks deep underground with a spawner of a weighted kind and chests with loot, and corridors carved from it to caves within reach, lined where they border cave or earth and lit sparsely outside the spawner's spawn area

One offer: the levels the player needs (0: no offer) and the enchantments it gives

An enchantment (enchantments/<name>.json, decision E-864), as in the reference game

What a player or an armour stand wears in the four armour slots (QcEquipmentSlot, decisions E-232, E-234): one stack each

Experience points something gives as orbs (decision E-398): a mined ore, a killed creature, a pair of bred animals; between min and max points, chosen evenly

A parent that splits off children and takes them with it (the Kjut, decision E-839), from its data (family): every fresh hurt it survives that takes health splits off childrenPerHit creatures of kind child while fewer than maxChildren of its children live and it has split fewer than maxSplits children in its life; when it dies, every child of it vanishes with popSound and leaves popDrops (like the children of a QObject on deleteLater), without an explosion

A feature a biome places (an entry of the biome's "features")

What a fishing rod does (decision E-503; "fishing" in the item's file): the use button casts bobber, a projectile kind, at speed and reels it in again

Settings of the flat world type (worldgen/flat.json): the layer preset a new flat world gets unless it names its own, "bedrock,59*stone,3*dirt,grass_block" (bottom up, n* repeats)

What a mode changes about the rules

How a creature with the golem AI fights, is repaired and built (decision E-471), from its data (golem)

Handbook of one content registry in one language (built by QcHandbookBuilder): categories with their entries, grouped by pack, and a search over titles in this language and in English

Everything a handbook consists of; see the accessors of the same names

A chapter of the handbook about playing (controls, hunger, death ...), from handbook/*.json

One page of the handbook: a block, item, creature, biome, chapter ... with its facts, recipes and references to other pages

A reference to another entry (target is its id)

A titled part of the page: text (a small Markdown subset: paragraphs, "- " lists, **bold**), links or recipes

Titles, icons and entry ids of content in the handbook, and links to their entries

Recipes as shown in the handbook, and the sections every item page has about how the item is made and what it is used for

Where an item frame or a painting hangs and what it shows (decisions E-790, E-791), the same for the server (placement, support, saving) and the client (targeting, drawing)

Health line (decision E-834): every interval one info line "HEALTH …" in qtcraft.health with memory (resident and peak), frame and tick times, chunks, entities, players, round trip and network rates, so a log of a long playtest shows how the program fared before a problem

One thing a projectile does when it hits (decision E-427), an entry of its kind's "onHit" list: {"type": "knockback", "strength": 0.5}

Defaults of every category (held.json); a later pack's file overrides the fields it sets

Bounds one value of a vector must keep, both inclusive

A creature that hovers (the Kjut, decision E-839), from its data (hover): it floats height metres above the ground or the liquid below it, bobbing by bob metres every bobSeconds, never higher than maxHeight above the ground and lower under a low ceiling; it flies without gravity towards where its brain wants to go, rises over a wall in its way and turns to face where it goes at no more than turnSpeed degrees a second

One end of an in-process link

Collects durations until take() hands out their mean and maximum and starts anew

Player inventory: hotbar slots 0..8 followed by the main storage

An item kind of a content pack (items/<name>.json, QcItemParser): its stack size, tool, food and fuel values and all the ways it can be used

A number of identical items, e.g. one inventory slot

A saved component this version does not read (decisions E-420, E-823), kept as raw bytes so that saving again loses nothing: a component of an unknown id whole, or, for a known component of a newer version, the fields after the ones this version knows (tail), written back after them under the newer version

A binding moved away from another action to resolve a conflict: action's slot now holds key (the key the rebound action had before, 0 = none)

What a creature lays now and then (a chicken's eggs, decision E-452): an awake adult drops item at its feet after a time chosen evenly between minSeconds and maxSeconds, anew after each one, and sound plays there

Sections that hold cells and the bytes they take, per channel

Light of one chunk computed on its own (its neighbours dark walls), on any thread

How every block state treats light, indexed by runtime block id (decision E-389): the opacity (light lost entering the cell, 15 stops it), the block light it gives off and the faces light cannot cross (QcLightPassage)

Links of a handbook section, one per target: a link to a target that is already there adds its note to that one

What a liquid turns into where it touches another liquid (lava next to water)

A load that failed (a file, a definition, the base game): why, and the warnings collected up to there (decision E-975)

One log file with a size cap (decision E-834): lines are appended unbuffered, so a crash loses none of them; when the file would grow beyond the cap it becomes the rotated part 1, older parts move up by one, the oldest beyond rotations is deleted and a new file starts

Login settings of a server open to network players (decision E-252); a single-player world opened to the LAN gets them when it starts listening

A pool of entries drawn from a number of times

What draw() needs to know of an item: its id and largest stack

Thread-safe hand-over of values of the type T from producer threads to one consumer

Picture of one map (decision E-799), the same for the server, which reveals and saves it, and the client, which keeps what the server sent: size x size pixels over a square of the world that lies on a fixed grid of its scale (the map of a block column is the same for every holder), each pixel the top block of its column with a shade (QcMapPixel), 0 where nobody has looked yet

A material that building parts are made of: a base block and its kind

When a line was written: the local time and the milliseconds since the log started

One of the latest lines

A biome with its own chance of a surface entrance

Data definition of a creature: stats, behaviour, spawning, model and drops

One box of a mob's model, in metres relative to the mob's feet centre, facing north (-Z)

One bone of a skeleton model: boxes that turn together around a pivot

A skeleton model for creatures and players (a file in models): named bones with boxes that outfits texture by slot

One command or macro

One chat line as the server sent it to the players, with when (ms since the epoch) and who wrote it (empty for lines of the server)

Server -> client: operators, whitelist and bans

Server -> client: the log's tail (tail, answering a subscription or LogTail) or new lines

Server -> client: everyone playing, with the server's view of each

Server -> client: the outcome of an AdminRequest (id 0 answers a subscription or ends it), with the command's replies as chat lines

Server -> client: game rules and server limits with what a settings page needs

Server -> client, about once a second while the operator follows the status

Server -> client: the receiving player's progress in the adventure guide (decision E-923)

Client -> server: hit an entity with the held item

Server -> client: blocks set together in one tick (an explosion's, decision E-604)

Server -> client: the items lying on the campfire at pos (decision E-772), sent after the ChunkData of its chunk and whenever they change; one content item id per slot, 0 for an empty one

Client -> server: chat line or command starting with '/'

Client -> server: take offer slot (0–2) of the open enchanting table

Server -> client: the labels floating in a chunk (decision E-222), sent right after its ChunkData when there are any; they go with the chunk's ChunkUnload

Client -> server: the anvil screen closed

Client -> server: the enchanting screen closed

Client -> server: the stonecutter screen closed

Client -> server: use the held item without a target: eat it, or put on held armour (swapping with what is worn in its slot)

Client -> server: craft a recipe directly from the inventory (recipe book), count times

Client -> server: which debug data the client wants while its debug display, the control interface or the statistics log needs it; 0 stops it

Client -> server: the use button pressed or released with a launcher in the hand, or the draw given up (a screen opened, decision E-425)

Client -> server: the lines the player wrote on the sign at pos

Server -> client: the open enchanting table's slots, the bookshelves that count, the offers and the rune seed the screen writes the clues with (decision E-884: a random value of the player's own, drawn anew with the enchanting seed but not derived from it, so the order of the readable letters stays until the player enchants and tells nothing about the offers)

Server -> client: positions of all visible entities that changed this tick, with the server's time of the tick (players' time, QcServerClock::playerTimeNs, in ms) for the client's interpolation buffer (decision E-271)

Server -> client: an entity came into view, with its kind (decision E-365); a creature also names its type, an index into the content's mobs

Client -> server: the client's timer says the block is broken; the server checks the time itself

Server -> client: the receiving player's game mode (decision E-282), after the welcome and with every change

Server -> client: the receiving player's complete inventory, crafting grid and armour slots

Client -> server: measures the round trip of the connection (decision E-886)

Server -> client after Hello from a remote client: what the server needs for the login

Server -> client: contents and progress of the open machine

Where a creature is heading: chasing a player, wandering or fleeing

Server -> client: the player opened the anvil at pos (decision E-866); AnvilState follows

Server -> client: the player opened the enchanting table at pos (decision E-864); EnchantingState follows

Server -> client: the player placed or used the sign at pos; the client opens its editor with the sign's current lines

Client -> server: the player opened (paused) or left the pause menu (decision E-877)

Server -> client: measures the round trip for the admin channel's player list (decision E-848); the client's tick thread answers at once with a Pong of the same nonce

Server -> client: the receiving player's experience (decision E-398): his level and the points towards the next one, which needs pointsForNext (QcExperience::pointsForNext, sent so the client needs no curve)

Server -> client: the receiving player's health; dead players wait for Respawn

Server -> client: everyone on the server, sent to all whenever someone joins or leaves, and every two seconds while a round trip changed (decision E-886)

Server -> client: authoritative state of the receiving player

Client -> server: shift-click on a slot

Client -> server: leave the death screen

Client -> server: choose the stonecutting recipe recipe for the input of the open stonecutter (empty: none); the server answers with StonecutterState

On the server (decisions E-374 to E-377): in its storage, under way (read or generated, waiting for their group), unloaded and not yet saved; groups of circuits among the loaded ones (more than one chunk), the largest, the one of the player's chunk, groups over the limit seen so far; load tickets of circuits (and those refused), forced chunks, chunk loaders

Client -> server: the player changed their look

Server -> client: a sound at a world position (block broken, creature hurt, furnace crackling)

Client -> server: the player starts hitting a block

Client -> server: take the crafting result once into the inventory

Client -> server: trade the offer at index offer of the open screen once, or with repeat as often as the inventory and the uses left allow (shift-click)

Server -> client: the trading screen of the villager villager opened or changed (a trade, a restock, a level gained)

Client -> server: use the held item on a block face (places blocks, opens doors)

Server -> client: the weather as this player sees it (decision E-395)

Server -> client: seconds since the world began and the length of a full day; running is false while the time of day stands still (game rule daylightCycle, decision E-221)

Instruments of a note block (decision E-767): the sound it plays for the block below it, by that block's name, else by its sound material, else fallback

One content pack as server and client compare it: id, version and a hash over its files (QcContentFingerprint)

One picture a painting can show (decision E-791): its size in blocks and its texture

Mean and maximum of a few series of times (milliseconds) over the latest samples, for the debug display (decision E-225): one sample per server tick or per frame, each with one value per series

Outcome of moveBox(): the movement that was possible and the axes on which blocks stopped it

Walking speed and jump factors of the block under a body's feet (mud), and its slipperiness (ice)

A chunk loader block of a world (decision E-377): where it stands and who placed it (QcChunkLoaders::Loader on the server)

Which block states keep rain and snow out of the cells below them (decision E-395): those that keep sky light coming straight down out (QcLightPassage::skyStop: opaque blocks, leaves, covered tops), solid blocks with a collision shape (glass, fences, slabs) and liquids

A water creature that swims in pulses (the squid, decision E-974), from its data ("aquatic": {"pulse": ...}): each pulse of seconds starts with a push of thrust times the pulse towards speed m/s, then it glides and slows down; hurt, it pulses twice as often at its chaseSpeed

What a rail state does to the carts on it (decision E-384)

Cell of the rail whose track meets end end of the track track in cell (the same height, one higher or one lower beside it), and which of its ends meets it; nothing at the end of a line

Track and behaviour of every block state of a content, looked up once (carts ask every tick)

Block a ray hit (QcRaycast::cast)

Round trip samples of the last windowNs (decision E-886)

A block that grows into a tree feature after a random time (saplings)

A part of a shape applies when every condition holds: the block's value of property is one of values

One part of a block shape: boxes and crossed planes that apply in the states where all its conditions hold

One category of the showcase world (an entry of "categories")

One ground layer: its block ("block") and its depth in blocks ("depth", at least 1)

A shy creature (the ocelot, decision E-480), from its data (shy): it flees from players closer than distance metres, except from one who holds one of its calmItems and moves no faster than calmSpeed m/s (sneaking up slowly with its food)

Ink of a sign text colour as red, green and blue (decision E-830): a tone of the dye dark enough to stand off the lightest planks (birch) at a contrast of at least 2:1

Signal Dust part of a block (the "signal" object, decision E-333): its kind and the numbers that tune it

Turns one input item into a result inside a machine of the same category (furnace: "smelting"); the stonecutter's recipes (decision E-784) have the category "stonecutting" and their own list

A sound effect, ambience loop or jingle described by synthesis parameters (content sounds/)

Weight a biome gives a monster kind instead of the kind's own (decision E-838): the husk's desert takes most of the zombies' share

What makes a block a monster spawner ("spawner" in block data, decision E-520): the rules it spawns its creature kind by

Degrees around the part's pivot like QcAnimator::BoneRotation: x (pitch) swings arms and legs forward and tilts the head up, y (yaw) turns it towards the stand's right, z (roll) lifts it outwards to the right

Status effects of a player or a creature (decision E-450): at most one of each kind

A boat (decision E-920) with its feet at at (a point, like a creature's), of the boat item item, pointing to yaw degrees (0: north). The JSON keys are the field names

A choice of the village planner (decision E-404): one of the options is taken per placed copy, each as likely as the others

An item frame or painting hung when the world is made (decision E-797, the showcase's station): on face of the block behind cell at (a painting's lower left cell), from item; a frame holds held turned by rotation eighths, a painting shows the motif motif. The JSON keys are the field names

A chest at at filled from the loot table table when its chunk first arrives (decision E-521). The JSON keys are the field names

An optional part of the village planner (decision E-404): cells in the structure's palette written over its own cells with chance per placed copy (keep: the structure's own cell)

Structure's footprint over the whole height of the world as a spawn area of the original game (decision E-871; "spawnArea": {"monsters": [...]}): a monster that spawns naturally in one of its columns is one of monsters, drawn alike, by the monsters' rules of light, ground, distance and cap, one at a time (QcSpawnAreas)

A stack of count (1 to 64, default 1) item; name and enchantments give it a custom name and enchantments (an enchanted book in a showcase chest, decision E-873). The JSON keys are the field names

Where the terrain generator places the structure by itself (decision E-590; "surface"): at most one copy per square region of spacing blocks (whole chunks), with chance, at the first of attempts places that lies wholly inside the region on land above the sea in one of biomes (all five samples of its footprint) whose ground varies by at most maxSlope; never within villageMargin blocks of a village

How long one arm swing lasts (decision E-881), shared by the client's animation and the server's cadence of swings while a player mines: the reference's six ticks (300 ms), one tick shorter per level of a hastening effect and two ticks longer per level of a tiring one

A creature that teleports (the shadewalker, decision E-460), from its data (teleport): to a random safe place within range metres (a solid floor, room for its body, no liquid, only in loaded chunks; QcSafeSpot), at most once per cooldownSeconds

How a texture animates (decision E-878): frames pictures shown for frameTicks game ticks (50 ms) each, in a loop; with interpolate the picture blends smoothly into the next one

Texture source as delivered by content packs

An item thrown by hand as its own projectile (a snowball, decision E-427): the use button throws one at once at speed, randomly turned by up to inaccuracyDegrees; the thrower waits cooldownSeconds before the next throw of that item

One offer of a profession (decision E-414): from level on, a villager may offer result for costs (one or two stacks, paid by the player), maxUses times until it restocks at its workstation

A number of items of one kind in a trade offer (by item name)

Bytes of the message frames a connection sent and received so far (health line, decision E-834)

Frame-based, bidirectional link between one client and the server

Grass and flowers of a biome (decision E-814): two weighted tables of plant blocks

Patches the generator lays out of one plant of the table (flower patches): a patch cell of patchCell × patchCell blocks holds one with chance, centred at a random spot of the cell; it tries tries columns at most radius blocks from its centre on each axis and plants one kind, chosen by weight, on every free one. Read from the "patches" object

One plant of the layer

Villages of the content (part of QcContentRegistry, server side only, not synchronised): village styles and settings (decision E-403), villager species and professions (decisions E-411, E-421) and the professions' offers (decision E-414)

Golems villagers summon (worldgen/villages.json "golem" or a style's "golem", decisions E-421, E-470), like in the reference game: a villager wants a golem while it slept in its bed within sleptSeconds

One street plan the villages of a style are laid out with (decision E-408), chosen per village by weight

A range a village draws one value from, uniformly: min to max, both included, of the type Value

One surface a village may lay its roads of one rank with (decision E-406): block goes into the ground's top block; step (a slab, optional) is laid on a road cell next to one a block higher, so a step on terraced ground reads as a stair

How a style over water stands (decision E-407): its pieces and boardwalks lie at one floor height above the water surface on posts down to the bottom, and stairs lead down where a boardwalk ends on dry land

Ground a village over water shapes around itself (decision E-407, E-660, E-661): within margin blocks of its pieces and boardwalks (frayed by noise up to fray more) the ground lies at the water surface, blending back to the terrain over at least blend blocks; on it a noise of scale blocks forms pools depth blocks deep over water of the open ground, ringed by mudBand blocks of the bottom block, grass between, with plant beside the pools at plantChance and floatingPlant on their water at floatingPlantChance (lily pads, decision E-774); dry ground stays where stairs lead down to land

What the villagers of one village style wear (decision E-411): an outfit, hair styles or headwear to choose from (an empty name: none) and the colours of the tinted layers (0xRRGGBB)

From from (a share of the day: 0 sunrise, 0.25 noon, 0.5 sunset, 0.75 midnight) until the next step the villagers do activity

Settings of the void world type (worldgen/void.json): air everywhere except a square platform of platform blocks around the world's origin (radius 0: none) at height platformY

What the weather does to the world (weather.json of a pack, decision E-396; server side only, a later pack replaces it)

Weather of a world as world.json keeps it (decision E-395): the current spell (kind and the ticks until it ends), how many spells the world has had, the strengths of rain and thunder, which fade towards the spell's kind, and how many ticks the weather has run

A structure picked by weight among others (decision E-975): the qualified structure name (key "structure") and its relative weight (key "weight", at least 1). Village blueprints and coastal towers use it

Metadata of a saved world (world.json)

One option of the world generation a player sets when creating a world (an entry of "options" in worldgen/options.json of a pack, decision E-917)

What one pack's worldgen/options.json adds; a later pack replaces groups, options and presets of the same name

Rules a world type sets once when a world of it is created (decision E-223): a time of day that stands still (seconds after sunrise) or the running day, and whether creatures spawn by themselves

A rectangle of columns (or of other cells on the x-z plane, such as regions) from (minX, minZ) to (maxX, maxZ), both corners inclusive