qc_server

Rules between the blocks of a world and its block entities, checked in one place (decision E-357; tests call it after their scenarios, a broken rule is a bug)

Turns the block entities of a running world into the records saved per chunk and back (decision E-358): ticks become ticks left (or since) at now and absolute ticks again when read

Blocks of one chunk as a blob of a region file (decision E-373): a palette of block state names ("name[property=value,...]") local to the chunk and the sections in the protocol's chunk encoding with indices into it, compressed

Parsing of command words shared by the commands

Components of a creature entry in the entities of a chunk (QcEntityCodec, decision E-420): health and breeding (Creature), the villager record, status effects, the carried block, the enclosure, the golem's builder, the laying timer, the tame state, a creature without a mind and the parent of a child of a kept family (decision E-839)

Entities of one chunk as a blob of its region file (entities/r.<x>.<z>.qen; decisions E-366, E-373, E-420): persistent creatures, dropped items and waiting drops, falling blocks and lit explosives, armour stands, minecarts (E-382), experience orbs (E-398), projectiles (E-425), and whether the chunk already got its animals, then item frames and paintings (E-793) and boats (E-920)

How an explosion reaches blocks and bodies (decision E-602), pure so that craters and exposure are testable on their own

Puts the world generator's chest loot, spawner kinds and minecarts (decision E-570) into a chunk that arrives (decision E-520, QcWorldGenerator::furnishingIn), once per chunk: the chunk is marked furnished and the mark is saved with its block entities, so a chest emptied since stays empty and a cart taken away does not come back

Who iron golems attack among the players (decision E-471), a light form of the reference game's popularity: a player who hurts a villager of a village, or a golem standing in a village's area, gives that village a grudge against them for the village style's grudgeSeconds (QcVillageGolemSettings), renewed by every hit; the village's golems attack them on sight while it lasts (QcGolemBrain::enemy)

Where item frames and paintings may hang (decisions E-790, E-791): on solid blocks, in cells without collision or liquid, not over another frame or painting on the same face

Server checks that a player can reach and see what they act on (decision E-092): the same voxel raycast the client aims with (QcRaycast, visible blocks; liquids do not block) from the eye towards sample points of the target

How a map is revealed (decision E-800), as in the reference: a player holding a map looks at the pixels within revealRadius blocks of where it stands, each tick at every sweep-th column of pixels (another one each tick), so a map fills in over sweep ticks while its holder walks and each tick costs little

How a minecart moves in one tick (decision E-382), for one cart on its own: on a rail it follows the track from end to end and on into the next rail whose end meets it (also up or down a slope), keeps its momentum, speeds up downhill and slows uphill and loses speed to drag

Data the creatures exchange with the rest of the server (decision E-422): what they know of the players (PlayerView), the blows and block changes their brains decide in a tick and the server carries out after it (PlayerHit, CreatureHit, BlockAction), and a persistent creature as saved with the world (Stored)

How hovering creatures move (QcMobDefinition::hover, decision E-839; the Kjut): without gravity, at their hover height above the ground or the liquid below them (bobbing gently), lower under a low ceiling and never higher than their highest hover above the ground; they fly towards where their brain wants to go, rise over a wall in their way and turn slowly to face where they go

Following a creature's path (decision E-400): it walks from waypoint to waypoint with the shared physics (jumping where the next waypoint is higher), checks that the next waypoints can still be stood on, notices when it makes no progress, and asks QcPathPlanner for a new path when the goal moved, the path is blocked or it got stuck, a chase path is old, or a partial path ended

How creatures teleport (QcMobDefinition::teleport, decision E-460): to a random safe place (QcSafeSpot::randomAround) within the kind's range around them or around a point (an angry one next to its target), at most once per cooldown, never when confined or without a mind (decision E-510)

Name tags on creatures (decision E-866): a name tag with a custom name (written at the anvil) used on a creature gives it that name, shown above it and in its death message; a named creature is kept (QcCreature::persistent), so it never despawns and is saved with the world

What a block state is to a walking creature looking for a path (decisions E-400, E-402), one byte per state, computed once from the content: the kind of cell, two flags and the height of a low block (or, for a solid block, whether it is slippery)

Who owns tame creatures (decision E-480): a player's persistent identity rather than an entity id, which changes with every login

What is saved of a player and how it comes back (decision E-367): the state of a connected player as a QcPlayerData for QcPlayerStorage, and a saved one put onto a player who joins again

One region file of a world (decision E-373)

Binary save file container shared by every world file except world.json: [magic][quint16 version][quint32 payload size][quint32 crc32][payload]

Light test of monsters (decision E-836), as in the original game: a cell is dark enough when its sky light passes a random draw of 0..31, its block light (torches) is at most the rule's maxLight (0 for monsters) and its brightness, the larger of block light and the sky light less the darkening of the sky by time and weather, is at most a random threshold of 0..7

Properties of an armour stand that commands, structures and a later stand screen change (decision E-239), each checked here: "pose <part> <x> <y> <z>" (angles finite, normalised), "rotation <degrees>", "arms|plate|small|showname <true|false>", "name [text]" (cleaned, at most QcArmourStandManager::maxNameLength code points), "equip <set|item>" (armour into its slot, anything else into the hand), "cape <cape|none>" (an appearance of the kind cape), "clear" (takes everything off, the cape too) and "reset" (pose and flags)

One use of an item that wears (decision E-864): a tool mining, a weapon hitting, a bow shooting

Beds and workstations of villagers in the village state (decision E-411): a villager claims a bed and a workstation under its creature's persistent id (holder, QcCreature::uid, decision E-420; QcVillage::Spot::claimedBy) and counts in the village's population

Weather's course as a pure function of the world seed (decision E-395): after a clear spell comes rain or a thunderstorm, after them a clear spell again; the kind and length of each spell follow from the seed and the spell's number, so the same world has the same weather whatever happens in it, and /tick steps through it exactly

A banned name: the name, the reason, who banned it, since when, and the fingerprint of the banned identity (empty until known)

Lines (QcMessageLog) and the number of the newest line looked at: the next call asks for the lines after it, so none comes twice

What the server counts at the moment of a sample

A game event as the server's gameplay reports it to the adventure guide (decision E-923, QcServerAdvancements::trigger): the kind of event and the content names it involves (empty where the event has none)

/adventure (decision E-735), for operators: shows and changes the world's allow-lists of adventure mode, which item kinds may break which blocks (canBreak) and act on which blocks (canPlaceOn)

What an archer (QcMobDefinition::Ai::Archer, decision E-426) does between ticks: its draw, the side it circles to, where it last saw its target (for the lead of its shots) and its drink

Armour stands of a world (decision E-238): placed entities that wear armour and hold an item, with a pose, but no AI, no health and no physics; they stand where they were placed

Block side of explosions (decision E-602): the cells a blast breaks wait in order and are worked through at most explosionBlocksPerTick per tick (QcServerLimits), the rest in the next ticks; nothing is ever lost on the way, but a cell whose chunk left the world in the meantime is skipped

What a blast does to players and creatures (decision E-602), like the reference game: a body within twice the power of the centre takes an impact of (1 - distance / (2 × power)) × exposure, the share of points of its box that see the centre past solid blocks (QcExplosionRays::exposure)

Blocks around one explosion as its rays see them (decision E-602), each cell looked up in the world once and then read from a flat cache: a blast's rays cross most cells several times (steps of 0.3 blocks), and the sight lines to bodies cross them again

Commands that change blocks (decision E-245): /setblock, /fill (optionally only replacing one block), /clear and /regenerate

State that belongs to single blocks of the world (decision E-357), filed by chunk so that it moves, drops, is forgotten, saved and loaded with its chunk: the contents of containers (chests, barrels, hoppers with their cooldown, dispensers) and machines (furnaces), the timers of growing saplings, the memory of circuit components (torches burning out, openers last seen powered, pistons in the middle of extending) and the scheduled ticks of components

Positions of a chunk's entries by kind: the entries live in one table per kind, so lookups and ticks are one hash access, and everything of a chunk is found without a scan

State of a machine block (a furnace): its slots, fuel, work and experience

A blob that fits its limit, and the warning when the parts kept for a newer version or a mod were left out to make it fit

Every table of block entities of the world, whose entries kept tails belong to

What is saved of the block entities of one chunk (decision E-358), with every tick counted from the moment of saving, so clocks go on where they stopped when the world opens again

A scheduled tick of a circuit component: its cell, the ticks left and its priority

Screens of containers and machines the players have open (chests, hoppers, dispensers, furnaces, container minecarts): opening, closing, sending their state

Per-tick block simulation of the server: queued neighbour updates (connections, lost support, starting falls through QcServerFallingBlocks, fire that lost its place going out) and liquid flow

A pending neighbour update

Boats of a world (decision E-920), the table of their kind in the entity register: adding, finding and removing them within the world's limit, and the step of the boats nobody drives: they push each other apart, living bodies push them, and each moves by the shared boat physics

Boxes sorted into the columns of a horizontal grid (decision E-920), so a box is compared only with the boxes in the columns it covers instead of with every other: the boats that push each other and the creatures a boat picks up

One place on a campfire and the item cooking there

Latest chat lines everyone on the server saw (decision E-848): players' chat and /say, with when and from whom, numbered in the order they came, for the admin channel's chat view

Chunks kept loaded on purpose (decision E-377): /forceload add|remove|query, by block coordinates (~ relative to the player) of one chunk or of the corners of an area

Reading and writing the chunks of a world in the background (decision E-373), so the server tick never waits for the disk: one thread owns the QcChunkStore and runs every request in the order it was made, so a chunk read after it was handed over for writing gets what was handed over

What is kept of a chunk that leaves the world or is saved: its blocks when they changed since they were last handed over (none: what is stored stays), its block entities and entities (empty records remove what was stored) and its circuit marks

Which loaded chunks a circuit or machine connects across their border (decision E-375), kept up to date as chunks arrive and blocks are set, never computed per tick

Which chunks the server keeps loaded and how they come and go (decisions E-374 to E-377)

What the storage holds of the chunks and how the loaded chunks stand towards it (part of QcServerWorld, decision E-716): the catalog of stored chunks, the loaded chunks whose blocks changed since they were last kept or differ from what the generator makes, and the chunks whose stored data is damaged (decision E-373)

Chunks of a world on disk (decision E-373): per kind (blocks, block entities, entities) one indexed region file per region (QcRegionFile), read chunk by chunk when a chunk is needed

Kind and file (relative to the world directory) open() failed on; journal: the journal of a save that broke off cannot be finished (damaged, or a staged file is lost)

A whole file of the world written with a commit (world.json, blockupdates.qce); no content removes it

Load tickets of circuits (decision E-376): chunks loaded for a while although no player is near

Something lies on in this tick, those a player or creature stands on and those a minecart stands on; tripwire something touches (decision E-782)

A door, trapdoor or gate at pos to set open or closed

Work of the circuits of a world between ticks (decision E-335): block changes near circuits not yet looked at, positions waiting for chunks to load and comparators to read again

Takes out every position of a chunk that leaves the world and that the circuits were going to look at (changes, positions waiting for chunks, comparators to read again); they go with the chunk's record and wait again once it is back (decision E-374)

What the clients get after a tick besides their own state: the world around them (chunks, entities, debug data) and the time of day

/help (decisions E-243, E-911): without a word one line per group (QcCommandCategory) with the commands the source may run; /help <group> [page] those commands with their descriptions, pageSize to a page; /help <command> its usage, its description and the words its usage cannot name (QcCommandSpec::names, the structures of /locate)

Who runs a command (decision E-243): a player through the chat or the server console

What a Signal Comparator reads from a block (decision E-343): the fullness of a container or machine with the reference formula, a state property scaled to 0..15, or the fullness of a container cart on a detector rail (decision E-385), as the block's data says

Reads the fields of a known component of a version from a stream: a reference to a callable that outlives the read, without the allocation of a std::function

What read() keeps of one entry's components besides the known fields, and how many unknown components it dropped beyond maxKept

Bounds new connections per network address (decision E-254): a token bucket per address against connection floods, and a cap of open connections per address and in all

What touching blocks does to a body: the strongest damage and the longest burning (ticks), and whether a block of them burns items

A creature (decision E-364): a mob of the content's definitions (type indexes them) with its health, behaviour timers and breeding state

What creatures with traits do to the world (decision E-460), after the creatures' tick: the blocks they took and put down (QcMobManager::takeBlockActions) become ordinary block changes of the server (QcServerBlocks: clients, light, neighbour updates, saving), the teleports since the last call (QcCreature::teleportedFrom) play their sound at both places and show the clients the new place at once, and a creature that dies drops the block it carried

Creatures that crumble at a liquid's source (QcMobDefinition::crumbles, decision E-593; the sand golem in water), every game tick after the creatures moved: an awake one whose body (grown by touch sideways and below) reaches into a source block of its liquid is removed without loot or experience, and its build stands where it stood: body at its feet, in the middle above them and on both sides of the middle across its facing, head on the middle, facing where it looked

How creatures that open doors (QcPathRules::opensDoors, decision E-423) go through them: they open the closed wooden door on their path ahead (QcMobNavigator::Navigation::door) and close the one they opened once they are through, and they take turns at a door, one at a time (decision E-411)

Air under water in the server tick (decision E-955): players and creatures with their eyes under water lose their air (QcAirSupply) and then drown while the game rule drowningDamage holds; out of the water the air comes back

What a recomputation found

/effect (decision E-450), for operators: gives a player a status effect for some seconds at a level, or takes one or all away

What every entity of the server has (decision E-364): an id unique among all entities of the world, its kind, where it is and how it moves (feet in the middle of the bottom face), the direction it faces and whether it rests because its chunk (QcEntities::chunkOf) is not loaded

What is saved of the entities of one chunk (decision E-366): the chunk holding each one's feet

Tells each client about the entities near it (decision E-364), the same way for every kind: a spawn when one comes into view or its spawn data changed, moves for known ones and a removal when one is out of sight, rests or died

/xp (decision E-398), for operators: adds to, sets or shows the experience of a player, in points (the default) or levels

Experience orbs of a world (decision E-398), the table of their kind in the entity register

Blocks that fall (sand, gravel) while nothing holds them (decision E-055)

What lights fire besides fire itself (decision E-393)

A burning fire with an entry in the queue

Traits of every block state of a content, indexed by block state id

How water creatures move (fish, decision E-502), part of QcMobBehaviour: in water they swim without gravity along routes to goals where their body has room (QcSwimRoutes, a fleeing one away from danger), rest a moment at each goal and keep their whole body in the water (QcSwimSpace), steered also towards their school (cohesion, alignment and separation among the nearest creatures of their kind, schooling); a creature that swims in pulses (the squid, QcMobDefinition::pulse, decision E-974) pushes at the start of each pulse, glides between and tilts its body along its way (QcCreature::tilt); one without a mind (QcCreature::noAi) holds its place; out of water they fall, flop about and count their dry ticks (QcCreature::dryTicks), which QcBodyBurning turns into suffocation

Index of the generated chunks of a world (decision E-946): every chunk that was ever in the world, whether its blocks changed or not, so a later generator change knows the explored area

Brain of golems (QcMobDefinition::Ai::Golem, decision E-471): an iron golem guards the villagers

Zone a guardian keeps to (decision E-594): the guardian zone of a structure it came into (QcGuardSite, decision E-591), in world cells with both corners inside

Guardians that come back to the zones of structures (decision E-591; the sand golem in the cellar of a desert temple, a renewable source of sand)

Item frames and paintings of a world (decision E-790): placed entities without AI, health or physics

What one hit does to the body

Brain of hostile creatures (QcMobDefinition::Ai::Hostile): they chase the nearest player they see (and for a few seconds one they lost sight of, decision E-401) along a path and strike it in melee with a line of sight; without a target they wander like passive ones

Short invulnerability of a player or creature after a hurt (decision E-429), counted in game ticks (the server's simulation ticks, independent of /tick rate)

One registered identity: the player name, the identity (QcLoginCrypto::keyBytes bytes), its fingerprint and when it was registered

Slots of containers (chests, barrels, hoppers, dispensers) and machines (furnaces) as Signal Hoppers, droppers and dispensers reach them (decision E-344)

A dropped item stack lying in the world (decision E-364); QcItemEntityManager moves, merges and ages them

An item stack that is to appear or waits in the queue: the stack, its position (feet) and velocity, the seconds before it can be picked up and its age in seconds

Lag spikes in the server's log (decision E-834): a tick longer than 50 ms becomes a line with its duration and its longest phases

Counts since the server started (tests, measurements)

Flowing liquids on the server (decision E-054)

Warnings of reading a world's saved chunks (blocks, entity and block entity records): the readers add to it as they go, so what they found before a damaged part stays

What one player has not received of one map yet (decision E-802): per row the span of pixels changed since, and the row to go on from

One pixel looked at: where it is and what it shows now (QcMapPixel)

Where a cart came to rest on a level rail, at the lower end of a slope that ends there or on the ground off the rails (not saved): while it stays there, without speed, pushes, a rider getting in or a change of that rail or of the cells beyond its track's ends (off the rails: of the cells around it), its tick has nothing to do

How items move between minecarts and the blocks around them (decision E-387), once per tick after the carts moved, for awake carts only

What a cart carries, from its item (QcItemDefinition::cartBlock, decision E-386)

What the awake creatures of QcMobManager do each tick (decision E-400): each thinks with the brain of its AI (QcMobDefinition::ai, decision E-423: QcPassiveBrain, QcHostileBrain, the villagers' QcVillagerBehaviour, QcArcherBrain, QcNeutralBrain, QcGolemBrain, QcGuardianBrain); flyers drift above the ground, hoverers (QcMobHover) float after their brain's wish

Creatures that thought fully, throttled and not at all in the last tick (tests, measurements)

Breeding of peaceful animals (decision E-293), on the timers of QcCreature

A creature cramming hurt: its kind, where it stood and its drops when it died

A creature in a cell with more than the limit of them: its id, its index in the list build() counted, its cell (an index) and the number in the cell

A block a creature takes or puts down in a tick (a shadewalker, decision E-460), which the server carries out after the tick with the usual block changes (QcCreatureTraits): taking only when block is still there, placing only into air; dropping (game rule mobGriefing off) lets the carried block fall as an item

A blow of a creature at a player; the server deals it after the tick

What a hoverer does this tick: the steering of its brain (a horizontal wish and a speed) and, for an orbiting child, the height its feet keep instead of the hover height

Creatures laying now and then (a chicken's eggs, decision E-452), on QcCreature::layTimer: an awake adult of a kind with QcMobDefinition::laying counts its time down and lays when it runs out, then chooses the next time evenly between the kind's minSeconds and maxSeconds

How many questions to the routes are left this tick

What a walker remembers of its way between ticks

Shore to swim to (none on dry ground or while a path leads on), and whether the routes were asked

What to do this tick: the steering, and a closed door on the path or in the doorway the creature stands in (only for creatures that open doors, QcPathRules::opensDoors: villagers open it, QcVillagerBehaviour)

A hostile creature without AI of its own (a crowd, QcMobCrowd) strikes the nearest player in melee (inMelee) when its attack is ready, so a knot of creatures is no safe place (a neutral one only the player that provoked it)

How many monsters may live around the players (decision E-836), by the original game's formula: every living player spans an area of 17 × 17 chunks around its own; the world as a whole holds at most perArea monsters (QcServerLimits monstersPer289Chunks, 70) for every 289 loaded chunks of all areas together, so players far apart each bring a full share and players close together share one

Blocks a piston moves, as the clients see them (decision E-337): the world holds every moved block at its new cell at once (saves, chunk borders and other players see one consistent world), while the clients get the new cells only after the move and meanwhile see the block as an entity that slides there

Time of day and how dark the sky is (QcSpawnLight::skyDarkening)

Brain of neutral creatures (QcMobDefinition::Ai::Neutral, decision E-460; the shadewalker): they wander like passive ones until a player provokes them, then chase that player like hostile ones for angerSeconds, renewed while they see them

Opens and closes doors, trapdoors and gates, for players and for circuits: both halves of a door together, with the block's sound, but never onto a living body (a player or creature inside the new shape keeps it as it is)

Point of a waypoint: the middle of its cell (of the body's columns, QcPathTerrain::pointOf, and for a wide wall climber going up or down at the wall, QcPathTerrain::climbPoint), moved to the middle of the opening along the axes the gap it keeps to narrows (gap: the gap of its cell where the path goes through along the panel, else across the line of the path that of the waypoint just before or after it in line); for a waypoint right before or after a door (narrowed only by its neighbour in line), the axes it lines the creature up along

What the creature steers to for its next waypoint this tick: the waypoint's point (arrival and progress are measured to it) and the lane its body keeps to on the way

Cells of every block state of a content, indexed by QcBlockId

A* over the cells a creature can stand in (QcPathTerrain), bounded by a node budget and by the window around the start (QcPathWindow)

Where a creature walks: the world, the path cells of its blocks and the creature's path rules

Path searches of all creatures within a budget per tick (decision E-400)

A path as feet cells after the start, in order

One place a creature can stand in: its feet cell, how high it stands on a low block in that cell (a slab: half a block, a carpet an eighth) and whether it is in water

Cells around the start of one search (decision E-400): a box of 64 x 32 x 64 cells, each read from the world at most once per search, and the A* bookkeeping of its nodes

Players using items on tameable creatures (decision E-480): a taming item tames a wild one with its chance (a wolf becomes a dog; the pet sits at first and belongs to the player's identity, QcPetOwners); on a tame one, healing food heals it, a dye colours its collar, and anything else (an empty hand too) makes it sit or stand up, all only for its owner except healing

Carries out piston plans (decision E-337)

Blocks with random ticks: plants that grow upwards by themselves (blocks with growth, e.g. sugar cane), crops and soil (QcCropGrowth)

What a tick may ask of the world around the plants

What is saved of a player (decision E-093): his body, view, inventory, armour, health, food, game mode, experience, seeds, effects, advancements and air

Health and food of the players (decision E-367): regeneration and starvation, damage (with armour, knockback and the short invulnerability after a hit), falls, the void, death with its drops and message, respawning, eating, and telling the player

Parts of the server a join uses: persistence, inventory, health, game modes, chunk streaming and how to send the time

A player's saved state and the number of items of an open crafting grid that did not fit into its inventory

A player as read, with the warnings of reading his file (unknown items dropped, an unknown game mode played as survival)

A lit explosive counting down to its explosion (decision E-601); QcPrimedExplosives moves it like a falling block and counts its fuse down, QcServerExplosions sets it off

A projectile flying or stuck in a block (decision E-425); QcProjectileManager moves, sticks and ages them

Result of one step of a projectile

A projectile met a block (a target reads where, decision E-768)

A projectile that hit a body this tick

A player as the tick sees them for pickups

Limit of a bucket: tokens refilled per second and the bucket's size

Blob of a chunk to write or as read

Where to look for a place to stand around a point

When the server saves on its own: autosaves and the identities of new players

Authoritative game server

Adventure guide on the server (decision E-923): tracks per player which criteria of the content's advancements are met (QcServerClient::advancements) and tells the client

Anvil's screen in the server (decision E-866), as in the reference game: using an anvil opens it; the player puts a stack into the left slot (machineInputSlot) and optionally material, a second item of the kind or nothing into the right slot (machineFuelSlot), types a name and takes the output (QcAnvil::result) for its levels (nothing in creative mode)

What players do with boats and how boats move in the server tick (decision E-920): placing a boat from its item on water or on the ground, breaking it with a hit (it drops its item), getting in with a use and out with sneak, and driving it: each input of the driver steps their boat by the shared boat physics (QcBoatState::step) with the input's keys, the same step the driver's client predicts, so driving needs no correction

Server-internal state of one connected client, shared by the parts of QcServer, grouped by what it is for (decision E-367)

Open anvil (QcServerAnvil, decision E-866): where it stands, its left and right slots and the text of its name field

Open enchanting table (QcServerEnchanting, decision E-864): where it stands and the stacks in its item and lapis slots

Creatures this player fought lately (decision E-480): the last that hurt them and the last they struck (entity ids, 0: none) with the tick it happened; their pets defend them (QcMobManager::PlayerView::hurtBy and struck)

What the client may send: inputs refilled each tick by the real time it stands for, one per 50 ms (decision E-249), so other tick rates and sprints keep the player's pace; budgets of the other spammable messages; the latest input applied; positions whose true block was resent in tick miningResendTick after a dropped mining message

Block being mined, since which tick and players' time (QcServerClock::playerTimeNs)

What a client knows of an entity: the stack count of an item, the position of its last move and whether that move came in the last tick (QcEntitySync)

What the client has been told about the world: chunks streamed around the player within distance, entities it knows (SentEntity), known entities whose spawn data changed and must be sent again, and the debug data it subscribed to (QcMsg::DebugSubscribe) and when that was last sent

Players attacking creatures (decision E-367): reach and sight, the attack cooldown, the damage of the held item and its wear, the creature's sounds and the loot it drops when it dies

Command layer of the server (decision E-243), shared by the chat of every player and the server console: plain chat lines go to everyone, lines starting with '/' run a command of the registry or a macro of the content (decision E-248) after the source's rights are checked

Crafting of the players (decision E-367): the 2 x 2 grid of the inventory and the 3 x 3 grid of a crafting table near them, recipes and repairs taken from the grid (once or as often as possible), recipes crafted straight from the inventory (CraftRecipe) and the grid's items going back into the inventory when it closes

Debug data for the clients that ask for it (QcMsg::DebugSubscribe, decision E-225): the tick phases of the server's window, its counts and, on request, where the creatures near the player are heading

Enchanting table's screen in the server (decision E-864), as in the reference game: using a table opens it; the player puts an item into the item slot (machineInputSlot) and lapis lazuli into the lapis slot (machineFuelSlot) and sees three offers, whose levels depend on the bookshelves around the table (QcEnchantingTable::shelvesAround) and whose enchantments follow from the player's enchantment seed

Explosives and explosions in the server tick (decisions E-600 to E-604)

Falling blocks in the server tick (decisions E-055, E-288): a block that loses its hold becomes a falling-block entity (QcFallingBlockManager, a kind of the entity register) or, when too many fall, drops straight to its resting cell; one that comes to rest becomes its block again (concrete powder hardens in water) or breaks into items when the cell is taken or a body is in it

Game modes of the players (decisions E-282 to E-285): the mode of new players, changing a player's mode with the inventory set that belongs to it, the items of the creative catalogue and picking blocks with the middle mouse button

Cells of a built golem: its head, the middle and foot of its body and its two arms

Signal Hoppers of the server (decision E-344), run at the end of the signal phase

What players do to the world: mining blocks, using blocks and items (opening machines, toggling doors, switching levers, tilling, carving, lighting fire, placing blocks and building golems from them, scooping liquids) and using creatures (feeding, repairing golems, catching)

Dropped items in the server tick: they move, merge and despawn (QcItemEntityManager), and players pick them up

Budgets and bounds of the server's simulation that an operator may tune (decision E-349): read from the object "limits" of server.json on a dedicated server, of world.json in a single-player world (a dedicated server ignores the world's)

Server's side of the handshake (decision E-252)

What players do with maps in the server (decisions E-800 to E-804, E-807, E-808): using an empty map makes a filled map of the land around its user, holding a filled map reveals the land around its holder, and the holder and the players near an item frame showing the map receive what changed of it, at most pixelBudget pixels per player and tick, with the players who carry the map and the frames showing it as markers

Whether the server's tick loop pauses (decision E-877)

Plants in the server tick: growing saplings and decaying leaves (QcPlantManager), random ticks of plants that grow upwards like sugar cane, of crops and soil (QcPlantGrowth), items that plant themselves (despawning saplings, seeds lying on free soil; decision E-294), and players tilling soil with a hoe (decision E-290), making paths with a shovel (decision E-406), bone meal on crops and saplings (decision E-426) and carving pumpkins with shears (decision E-472)

Settings of a dedicated server (decision E-255), kept in server.json in the data directory (or a file given with –server-config) and overridden by command line options: name, message of the day, port and bind address, player limit, password, world, view distance limit and the connection limits

Sends sound events to the clients that can hear them

World, the clients and the entities of the authoritative server, shared by its parts (decision E-367): each part is reached through its own accessor and keeps its data behind its own interface; what changes at the level of the whole server (the clock, the player list) changes through a named function

Gameplay systems of a server: each runs its own part of the tick on the world and its bodies (fire, weather, health, minecarts, boats, experience, projectiles, circuits, explosions, the players' mining and using)

Vehicles of the server, minecarts (decision E-382) and boats (decision E-920), and what the server asks of both at once: a hit or a use of an entity, the input of a rider, getting out, the tick, which vehicle a player is in

Weather in the server tick (decision E-395)

Authoritative block world of the server

Chunks the signals of the circuits concern (decisions E-376, E-378, E-410), for QcChunkLoading: the chunks signals wait for that are not loaded, the chunks of signals waiting for one on its way, the chunks with signals on their way, and the unneeded chunks a signal passes through, held for at most the time of a load ticket

Scheduled ticks of circuit components (decision E-335): a component asks to be looked at again after a delay (a torch after 2 ticks, a repeater after its delay, a button when it springs back)

QcSignalState of every block state of a content, indexed by block state id, and the states circuits switch to

Spawn areas of structures around the living players (decision E-871, the original game's spawn overrides): in the footprint of a witch hut over the whole height of the world the natural monster spawns bring forth only witches, by the monsters' rules of light, ground, distance and cap (QcNaturalSpawner)

Sky light, block light and darkening of a cell, and the brightest block light allowed

How monster spawners work (decision E-520), every game tick: a spawner with a creature kind counts its delay down while a player is within its block's range; at 0 it runs a cycle: unless maxNearby creatures of its kind are within nearbyRange of its block or the world holds QcServerLimits::spawnerCreatures creatures of spawners, it tries count random cells of its area and spawns a creature on each fitting one (room for the body's height and width, ground below unless it flies, block light at most maxLight for every kind, sky light not counted)

Reads item stacks of one save file by name (written by QcSaveFile::writeStack) with their data (QcItemDataCodec); an unknown item is dropped with one warning per name (QcLoadWarnings::addOnce), counts and damage are clamped to what the item allows (a stack with contents holds one item)

Chat commands for armour stands and armour (decision E-239)

Brain of tameable creatures (QcMobDefinition::tameable, decision E-480): a wild one thinks with the brain of its AI (wild: a wolf is neutral, a cat passive); a tame one belongs to its owner (QcTameState::owner, a player identity)

/tick (decision E-249): freezing the world, single steps, the tick rate, sprints and a query

Permanent, cheap phase counters of the server tick (decision E-225): one monotonic clock read per phase, no allocation per tick

Deadline-based tick schedule (decision E-090): tick n is due at start + n * interval on a monotonic clock, so late timers never shift the grid

Timing of the server ticks: how long they ran, how late they started against their due time on the tick grid (QcTickScheduler), and how many were skipped

One system: the phase its time goes to, when it runs and what it runs

Tripwire hooks and the tripwire between them (decision E-782), as decisions of a circuit step on the world before it

A village as the server knows it (decision E-403): where it is, its beds and workstations and who lives there

What fromJson() accepts: the box at most extent blocks wide (a plan never leaves its region, so the region's edge), each spot list cut to its own limit

A bed (its head) or workstation; claimedBy is the persistent id (QcCreature::uid, decision E-420) of the villager that uses it (0: free)

A word of /locate that names a place of the generator rather than a structure, with the name the answer shows (a server message key, translated by the client)

A golem the villagers summon

A villager as it lives in the world: its record and what it is doing (not saved; a villager loaded from its chunk decides anew)

Something a villager does to the world, carried out by the server (QcServerVillagers)

A child to spawn at position that moves into bed of village

State of one of a villager's offers (decision E-414), by the offer's id: how often it was traded since the last restock and how far demand raised its price

Villagers moving between villages (decision E-490), checked every few seconds by QcVillagePopulation

Long walks through a village (decision E-411): a path search covers only 64 x 64 cells around the walker (QcPathWindow, decision E-400), so a villager whose goal lies farther first walks to the cell of the village's roads that brings it closest to the goal along the roads, and from there on (legs)

An offer with its items resolved; costs at the base price

Bounds of the villages (QcServerLimits)

Random draws of one tick for purpose (strikes, snowfall), from the seed and the tick the weather has reached: the same world draws the same in the same tick, whenever the server was started

A finished backup: its folder, the number of files and their size in bytes

Reads and writes the files of one world directory besides its chunks: world.json, players (players/<name>-<hash>.qcp) and pending neighbour updates (blockupdates.qce)