Stations

Cooking stations store interaction state, input items, progress, fuel/fluid/stage data, and output handling. A station usually maps to a world block, a GUI, or a custom interaction entity.

Station types

Station	Main state	Best for
Chopping Board	Input item, accumulated amount, and cut count	Slicing and preprocessing.
Grinder	Input item and remaining time	Grinding powders or herbs.
Steamer	Input item, fuel, moisture, and steam progress	Steamed food and cooked intermediates.
Wok	Ingredients, heat, stir count, mistakes	Timing-based cooking gameplay.
Oven	Input, burn time, heat, and baking stage	Baking with heat control and stage resolution.
Juicer	Input, press count, fluid id, and fluid amount	Juice and drinks bottled by serving capacity.
Fermentation Barrel	Multiple inputs, progress, sealed state, and stage	Wine, vinegar, and fermented intermediates.

Common config fields

Field	Description
id	Unique station id.
display_name	Name shown in menus and messages.
block_item_sources	Block sources bound to the station. Prefer dash-style ids such as minecraft-oak_log.
interactions	Click mapping for each station operation.
permission	Permission required to use the station. Some checks are centralized in commands/listeners.
gui	GUI id or inline GUI config.
drop_result	Whether results are dropped directly in the world.
only_recipe_items	Whether only items that can match a recipe may enter the input.
disabled_worlds	Per-station list of disabled worlds, empty by default. In a listed world the plugin does not take over that station's events and vanilla block behavior is preserved.

World blacklist

Station interaction can be disabled per world at two levels, both defaulting to an empty list (nothing disabled):

# Global: applies to every station
station:
  disabled_worlds:
    - world_nether

stations:
  chopping_board:
    # Per station: applies to this station only
    disabled_worlds:
      - world_the_end

In a blacklisted world the plugin does not take over the related events and the block keeps vanilla behavior, so you can use this to preserve vanilla interaction in resource or instance worlds.

State storage and IO optimization

EmakiCooking chooses the station-state backend from the actual anchor block. If the block state implements Bukkit TileState, station state is written to that block entity's PersistentDataContainer (BLOCK_PDC). If the anchor is a normal block, the module falls back to YAML files under data/stations/ (YAML_FALLBACK).

This can further improve server IO-process performance:

• When many stations use block entities, state follows the chunk/block-entity save path instead of creating and rewriting one standalone YAML file per station.
• data/stations/index/<world>.idx stores only coordinates, station type, source, and backend so ChunkLoad recovery can locate stations by chunk without a full directory scan.
• Legacy YAML states are moved to data/stations-legacy-backup/ after a successful migration to block-entity PDC, keeping them available for investigation without leaving them on the hot path.
• Non-block-entity anchors still use YAML fallback; for large or performance-sensitive servers, prefer block-entity blocks as station anchors.

Diagnostics:

• /ec inspect block: checks the targeted block's block_state, tile_state, storage_backend, pdc_state, indexed, and legacy_yaml values.
• /ec station reindex: rebuilds the station coordinate index from legacy YAML and currently loaded PDC stations.

Minecraft block entity list (good station anchors)

The list below groups common vanilla block entities that Paper/Bukkit can expose as TileState. Availability still depends on the server version and the inspected block showing tile_state=yes. Wood, color, and variant families are merged.

Type	Common blocks
Containers	Chest, trapped chest, barrel, shulker box, ender chest, hopper, dispenser, dropper, jukebox, lectern, chiseled bookshelf
Processing / crafting	Furnace, smoker, blast furnace, brewing stand, campfire, soul campfire, crafter
Display / decoration	Banner, bed, sign, hanging sign, player head, decorated pot, bee nest, beehive
Redstone / utility	Comparator, daylight detector, command block, structure block, jigsaw block, moving piston
World / special	Beacon, enchanting table, bell, conduit, spawner, trial spawner, vault, end gateway
Sculk / archaeology	Sculk sensor, calibrated sculk sensor, sculk catalyst, sculk shrieker, suspicious sand, suspicious gravel
Newer API-exposed blocks	Copper golem statue, shelf, test block, test instance block

Chopping board example

stations:
  chopping_board:
    block_item_sources:
      - minecraft-oak_log
    only_recipe_items: true
    interactions:
      place_input: shift_left_click
      process: shift_left_click
      return_input: right_click
    drop_result: true
    interaction_delay_ms: 1000
    tool_item_sources:
      - minecraft-iron_axe

The chopping board input interaction takes the whole main-hand stack and accumulates it in station state; the item display entity still shows only one input item. In recipes, input.amount is the amount required and consumed for each completed cut cycle, and cutting cannot start until the accumulated amount is high enough. With cuts_required: 1, players can continuously process an already placed batch without re-placing one ingredient at a time.

Wok example

stations:
  wok:
    block_item_sources:
      - minecraft-iron_block
    interactions:
      add_ingredient: shift_left_click
      stir: shift_left_click
      serve: shift_left_click
      return_ingredient: shift_left_click
      inspect: shift_right_click
    drop_result: true
    need_bowl: true
    stir_delay_ms: 5000
    timeout_ms: 30000
    spatula_item_sources:
      - minecraft-iron_shovel
    heat_levels:
      - item_sources:
          - minecraft-campfire
        level: 1
      - item_sources:
          - minecraft-magma_block
        level: 2
      - item_sources:
          - minecraft-lava
        level: 3

Field	Description
need_bowl	Whether a bowl is required to serve.
stir_delay_ms	Minimum delay between two stirs.
timeout_ms	Treat the wok as overcooked after this timeout.
heat_levels[].item_sources	Block sources below the wok.
heat_levels[].level	Heat level produced by those blocks.

Grinder example

stations:
  grinder:
    block_item_sources:
      - minecraft-grindstone
    interactions:
      start: shift_left_click
    drop_result: true
    check_delay_ticks: 20

Field	Description
check_delay_ticks	Background check interval (ticks). The grinder starts automatically after input and checks progress at this interval.
interactions.start	Interaction type to manually start grinding.

The grinder is the simplest station — place an input item, it starts grinding automatically, and produces a result when the recipe time is reached. No fuel, moisture, or manual stirring required.

Steamer example

stations:
  steamer:
    block_item_sources:
      - minecraft-barrel
    interactions:
      open: shift_right_click
      fuel: right_click
      moisture: right_click
    drop_result: true
    heat_item_sources:
      - minecraft-furnace
      - minecraft-smoker
      - minecraft-blast_furnace
    ignite_heat_source: true
    fuels:
      - item_sources:
          - minecraft-stick
        duration_seconds: 5
      - item_sources:
          - minecraft-coal
        duration_seconds: 80
    moisture_rules:
      - input_item_sources:
          - minecraft-water_bucket
        item_sources:
          - minecraft-bucket
        moisture: 120
      - input_item_sources:
          - minecraft-potion
        item_sources:
          - minecraft-glass_bottle
        moisture: 40
    reset_progress_when_steam_empty: true
    steam_production_efficiency: 10
    steam_conversion_efficiency: 1
    steam_consumption_efficiency: 1

Field	Description
heat_item_sources	Block sources below the steamer that act as heat sources. Supports object format with lit_item_sources for lit-state replacement.
ignite_heat_source	Whether adding fuel lights the heat source block appearance.
fuels[].item_sources	Fuel item sources.
fuels[].duration_seconds	Burn time added by the fuel.
moisture_rules[].input_item_sources	Input item sources for adding moisture.
moisture_rules[].item_sources	Container item returned after adding moisture.
moisture_rules[].moisture	Moisture value added.
reset_progress_when_steam_empty	Whether to reset all progress when steam runs out.
steam_production_efficiency	Max moisture converted to steam per cycle.
steam_conversion_efficiency	Progress gained per steam consumed.
steam_consumption_efficiency	Base steam consumed per cycle.

Steamer logic: fuel provides burn time → burning converts moisture into steam → steam advances steaming progress. The three efficiency parameters control conversion rates. Both moisture and fuel must be manually replenished by the player.

Oven example

stations:
  oven:
    block_item_sources:
      - minecraft-smoker
    interactions:
      open: shift_right_click
      fuel: shift_left_click
      inspect: shift_left_click
    drop_result: true
    heat:
      min: 20
      max: 80
      decay_per_second: 5
    fuels:
      - item_sources:
          - minecraft-stick
        duration_seconds: 5
        heat: 10
      - item_sources:
          - minecraft-coal
        duration_seconds: 80
        heat: 35

Field	Description
heat.min / heat.max	Baking only advances while heat stays in this range.
heat.decay_per_second	Natural heat decay per second.
fuels[].duration_seconds	Burn time added by the fuel.
fuels[].heat	Heat added by the fuel.

The oven runtime records current heat, remaining burn time, accumulated baking time, and baking stage. Heat that is too low or too high pauses normal baking. Recipes can use perfect heat ratio and overbake time to resolve the final result.

Juicer example

stations:
  juicer:
    block_item_sources:
      - minecraft-cauldron
    interactions:
      open: shift_right_click
      process: shift_left_click
      inspect: left_click
      serve: shift_left_click
    drop_result: true
    only_recipe_items: true
    require_container: true
    max_fluid_ml: 1000
    default_serving_ml: 250
    container_item_sources:
      - minecraft-glass_bottle
    drop_completed_result_on_break: false

Field	Description
require_container	Whether a container is required to serve.
max_fluid_ml	Default internal fluid capacity in milliliters.
default_serving_ml	Default fluid amount consumed per serving.
container_item_sources	Items accepted as containers.
drop_completed_result_on_break	Whether completed results are dropped when the station block is broken.

The juicer stores output as a fluid id plus an amount. One juicer should only contain one fluid at a time to prevent mixing different drinks. The fluid amount must reach serving_ml before a serving can be bottled.

Fermentation barrel example

stations:
  fermentation_barrel:
    block_item_sources:
      - minecraft-barrel
    interactions:
      open: shift_right_click
      start: shift_left_click
      inspect: left_click
      serve: shift_left_click
    drop_result: true
    pause_when_open: true
    require_sealed: true
    only_recipe_items: true

Field	Description
pause_when_open	Whether fermentation pauses while the GUI is open.
require_sealed	Whether the barrel must be sealed before progress advances.
only_recipe_items	Whether only recipe ingredients can be inserted.

Fermentation barrels are suited for long-duration, multi-input recipes. Recipes can define early collection, normal completion, and over-fermented results.

Lifecycle

1. The player interacts with the station using a configured click.
2. The module checks permission, cooldown, occupancy, and held-item requirements.
3. A GUI or interaction state is opened.
4. The player inserts items, adds fuel/moisture, presses, or seals the station.
5. The station tracks progress such as cuts, grinding time, steam, heat, fluid amount, or fermentation stage.
6. Inputs are consumed and results are generated, or the station enters a completed-but-unclaimed state.
7. Actions run and temporary state is cleared. Remaining fluid, fuel, or progress may be kept.

Safety notes

• Avoid multiple players mutating the same item cache at the same time.
• If cooperation is allowed, define who receives results and who pays the inputs.
• Station state is persisted through block-entity PDC when possible; normal blocks use the data/stations/ YAML fallback.
• data/stations/index/<world>.idx records coordinates and backend so ChunkLoad restores inventories, progress, and displays by index while ChunkUnload drops runtime caches.
• If a block entity is removed or replaced directly, the index may still point to the old PDC station; use /ec inspect block to check backend/PDC state, then /ec station reindex to rebuild the index.
• For juicers, ovens, and fermentation barrels, verify fluid amount, baking stage, and fermentation progress serialization.

Display entities

Station inputs, intermediates, and results can be shown in the world through display entities, controlled by display_entities and display_adjustments.

Field	Description
display_entities.backend	Display backend: auto, packet_events, or bukkit.
display_entities.view_distance_blocks	Viewer distance in blocks.
display_entities.refresh_interval_ticks	Display refresh interval.
display_adjustments.defaults.item / defaults.block	Global defaults for item-style and block-style displays.
display_adjustments.station_defaults.<station>	Per-station overrides.

display_entities.text controls the runtime text display entity (result / progress / next-step hints):

Field	Description
text.enabled	Whether text display entities are used.
text.billboard	Facing mode: fixed, vertical, horizontal, center.
text.line_width	Maximum text line width in pixels.
text.background	Background color as an ARGB integer; 0 means fully transparent.
text.shadow	Whether text shadow is rendered.
text.see_through	Whether the text is visible through blocks.
text.defaults.offset / text.defaults.scale	Text offset and scale relative to the station block.
text.stations.<station>.enabled	Per-station toggle; enabled when omitted.

Item display adjustments

The item_adjustments/ directory sets per-item display parameters for specific stations. File names are not used for matching; the item source parsed from item_sources inside the file is the key, and only the last loaded file wins for a given source.

item_sources:
  - "minecraft-carrot"

stations:
  chopping_board:
    offset:
      x: 0.54
      y: 1.01
      z: 0.52
    rotation:
      x: 90.0
      y: 0.0
      z: 24.0
    scale:
      x: 0.72
      y: 0.72
      z: 0.72

  wok:
    offset:
      x: 0.47
      y: 1.0
      z: 0.45
    rotation:
      x: 88.0
      y: 12.0
      z: "-28.0-18.0"
    scale:
      x: 0.56
      y: 0.56
      z: 0.56

Field	Description
item_sources	Matching item sources. The parsed shorthand becomes the key for this adjustment.
adjustment	Optional shared adjustment for all stations. When this section is omitted, offset / rotation / scale are read from the file root instead.
stations.<station>	Per-station override, keyed by station folder name.
offset.x/y/z	Position offset relative to the station block.
rotation.x/y/z	Rotation angles. Range strings such as "-28.0-18.0" pick a random value.
scale.x/y/z	Scale factors.

A file is skipped when it has neither a shared adjustment nor any recognizable station adjustment.

Station permissions

Permission	Description
emakicooking.station.chopping_board.use	Use the chopping board.
emakicooking.station.chopping_board.cut	Perform chopping-board cuts.
emakicooking.station.wok.use	Use the wok.
emakicooking.station.wok.stir	Stir.
emakicooking.station.wok.serve	Serve.
emakicooking.station.grinder.use	Use the grinder.
emakicooking.station.steamer.use	Use the steamer.
emakicooking.station.steamer.fuel	Add fuel to the steamer.
emakicooking.station.steamer.moisture	Add moisture to the steamer.
emakicooking.station.oven.use	Use the oven.
emakicooking.station.oven.fuel	Add fuel to the oven.
emakicooking.station.juicer.use	Use the juicer.
emakicooking.station.juicer.press	Press ingredients.
emakicooking.station.juicer.collect	Bottle juicer results.
emakicooking.station.fermentation_barrel.use	Use the fermentation barrel.
emakicooking.station.fermentation_barrel.start	Start fermentation.
emakicooking.station.fermentation_barrel.collect	Collect fermentation results.

All station permissions default to true. Individual recipes can further restrict access through their own permission field.

Testing checklist

• Players without permission cannot open or use the station.
• Breaking a station returns, drops, or processes materials according to configuration.
• Closing a GUI leaves the state as expected.
• Full inventory, reload, death, and disconnect do not duplicate or delete items.
• Multiple players clicking the same station do not create race conditions.
• Oven results are correct for low heat, valid heat, high heat, and overbaking.
• Juicer behavior is correct for insufficient fluid, enough fluid, wrong containers, and mixed-fluid attempts.
• Fermentation behavior is correct for early collection, normal completion, over-fermentation, and GUI pause.