Build Resource Processing for an Original Crafting Game

Design crafting stations with clear inputs, processing time, outputs, capacity rules, and tests for a cozy ecosystem game.

Seele Editorial TeamUpdated November 18, 2026

Resource processing turns gathered materials into something more useful: wax becomes a candle, fruit becomes a preserve, or fiber becomes thread. A good crafting chain teaches the player where inputs come from, what a station does, how long the job takes, and what the output enables. Design those rules before filling the game with recipes.

A cozy workshop turns gathered flowers and wax into jars beside an active beehive garden.
Gathering, processing, and useful outputs can share one readable workshop space.

Map input-to-output chains

Start with one short chain and write it as a recipe: inputs, station, duration, output, and next use. For example, gathered herbs and a jar can become a prepared infusion at a mixing table, which then supports exploration in a damp cave. This is an original design example; choose materials and effects that fit your own world.

Give every input a clear source. Players may harvest it, trade for it, find it in a biome, or receive it from another process. If a recipe uses an item that only comes from a later region, the chain can create a dead end. Map dependencies as a graph and check that each recipe is reachable from the start through available gathering and crafting actions.

Then decide what makes the output worth producing. It can unlock a new recipe, improve a tool, support a quest, or create an optional trade good. If a product has no meaningful use, remove the recipe or give it a purpose before asking players to produce it. A compact network of useful transformations is easier to understand than dozens of interchangeable outputs.

Use a simple recipe table to expose bottlenecks:

InputStationOutputWhy process it?
Raw wax + herbSmall stillSealed balmSupports a planned exploration challenge
Fruit + empty jarPreserving benchJar of preservesProvides a useful travel supply or trade option
Fiber + dye plantLoomColored clothUnlocks a craft or a cosmetic choice

These are hypothetical examples. The point is to explain why each transformation exists and how its output connects to player goals.

Define station jobs and timing

A processing station should accept a valid recipe, reserve its inputs, show progress, and deliver the output exactly once. Represent a job with a recipe ID, input quantities, start time or remaining work, output, and status. Decide whether the station works in real time, only while the player is nearby, or only while the game session is active. State that rule through consistent feedback.

Keep recipe validation separate from the station animation. First check that the recipe is known, the required station exists, the inputs are available, and output capacity can be reserved. Only then remove or lock the ingredients and start the job. If the station is interrupted, the player should receive the result that matches the rule they were taught: return reserved inputs, pause the job, or keep processing in the background.

Show both what is happening and what the player can do next. A station can display the active recipe name, a clear progress cue, and the output slot. If the player can cancel, explain what happens to ingredients. If the job cannot be cancelled, communicate that before starting it.

The player loads gathered wax and herbs into a small processing station with output jars ready nearby.
Keep the input side, active process, and output side visually distinct.

Handle capacity and interruptions

Plan for output space before a job begins. If the station has no room, either refuse the job with a useful message or allow it to finish and hold the result in a clearly defined buffer. Avoid consuming ingredients for an output that silently disappears. If multiple jobs can queue, set a capacity limit and let players see the queue before they add more.

For jobs that continue while the player is away, store enough information to calculate completion after loading: start time, duration, and whether time advances offline. For session-only jobs, use a saved remaining-work value. Do not mix these models accidentally. Test saving during a job, loading after the expected finish time, cancelling, and filling the output slot while processing is active.

Prevent duplicate outputs by giving each job a stable ID and a single completion state. If a completion callback runs twice, it should not award the product twice. Likewise, decrement inputs once when the job is committed, not again when the output is collected.

Connect products to progression and test

A process feels purposeful when players can use its output soon enough to understand the payoff. Put a relevant recipe, building option, trade request, or exploration challenge near the point where the product becomes available. If the output feeds another process, show that dependency in a journal or recipe book so players can plan rather than guess.

Finished jars and crafted goods are placed on a stall beside new seeds ready for planting.
Finished products can lead into trade, expansion, or another step in the crafting chain.

Test a short chain from source to final use. Confirm each input can be obtained, the station accepts only valid combinations, the timer finishes as expected, inventory changes once, and the output has the promised effect or use. Then test edge cases: missing input, full inventory, full station output, save and reload, cancellation, and an unavailable recipe.

Ask players to explain what they need and why they would process it. If they cannot tell which station to use, strengthen the visual or recipe cues. If the chain feels like repeated waiting, shorten the delay, add a useful choice during processing, or make the output more consequential. Do not extend every timer simply to make a game feel larger.

The official APICO publisher page describes the game as combining resource gathering, biology, crafting, and beekeeping minigames. That establishes the broad theme only; the recipe and station model here is an original tutorial design. SEELE’s documented game-creation capability can help start from a natural-language game concept, while the actual recipe graph, station behavior, and save rules still need to be checked in your prototype.

Frequently asked questions

How do you design a resource processing chain?

Start with a player goal, then list the source material, processing station, recipe, output, and next use. Check that every input is obtainable before the recipe is needed and that the output changes what the player can do. Remove steps that add waiting or inventory work without adding a decision, discovery, or useful result.

Should processing continue while the player is away?

Choose one rule that fits your pacing and explain it through the game. Real-time offline processing suits long-running production, while session-only work keeps the player present for short crafting loops. Save the job’s start time or remaining work consistently, then test leaving and loading around the expected completion moment.

What happens when an output station is full?

Either prevent the job from starting until space is available or reserve a visible output buffer that can hold the result. Tell the player which rule applies before they commit ingredients. Never consume inputs and discard the product without clear warning; that makes the station feel broken rather than constrained.

How can processing avoid repetitive busywork?

Make each process support a useful decision or a meaningful goal. Let players queue sensible batches, discover recipes through play, or choose between outputs when that improves the loop. Shorten delays that only force waiting, and avoid adding extra transformations unless they create a new use, tradeoff, or piece of world understanding.

Prototype one short chain, test its inputs, timing, capacity, and payoff, then add another only when it expands the player’s choices. Explore an AI game creation starting point for an original ecosystem crafting idea.

SEELE AI

Turn this guide into a playable build.

Start with a focused brief, then iterate in the Seele AI Workspace.

Start creating