Easy Custom Craft

A Minecraft Forge 1.20.1 mod that lets admins create their own recipes in-game — no files, no JSON. Recipes are stored per world/server and applied instantly.

Features

• Crafting table – shaped & shapeless (commands + 3×3 GUI)
• Cooking – furnace, blast furnace, smoker, campfire (xp + time)
• Smithing table & stonecutter
• Tags – use tag:… ingredients anywhere + create your own tags
• Any modded machine (Create, Mekanism, Thermal…) – scans every recipe type, detects its options, with command auto-complete, multiple inputs and fluids — all without JSON
• NBT results and modded items supported

Commands (/ecc)

• Public: list, preview <name>
• Admin (OP): reload, remove <name>, and create …:
  • create craft_with_gui
  • create craft crafting_table shaped|shapeless …
  • create craft furnace|blastfurnace|smoker|campfire|smithing|stonecutting …
  • create tag <name> <values…>
  • create modded_craft types [filter]
  • create modded_craft <type> <name> <input[,input2,…]> <output> [count] [key=value…]

Documentation (advanced)

Value grammar

Every "ingredient" position accepts:

Result positions take a concrete item (via the vanilla item argument, so NBT like minecraft:diamond_sword{…} works). In modded_craft only, key=value values additionally accept: fluid:<ns:path>[:amount] (default amount 1000), true/false, numbers, plain strings, and comma lists a,b,c (→ JSON array).

Recipe names are sanitized to [a-z0-9/._-] (other chars → _).

Crafting table

• shaped <name> <s1>[ s2..s9] result <item> [count]
  • Ingredients come first; the literal result ends the grid. Trailing empty cells are optional (omit them); use empty/air only for internal gaps.
  • Grid is filled left→right, top→bottom; the pattern is auto-trimmed to its bounding box. Up to 16 distinct ingredients.
• shapeless <name> <ing1>[ ing2..ing9] result <item> [count]
• count is optional (default 1, max 64).

Cooking

<station> <name> <ingredient> <result> [experience] [cookingtime]

• Stations & default cook time: furnace 200, blastfurnace 100, smoker 100, campfire 600 ticks.
• experience default 0.0. Result supports count + NBT (Forge object result).

Smithing & stonecutting

• smithing <name> <template> <base> <addition> <result> [count] → minecraft:smithing_transform; all three inputs required (1.20.1 rule). Result count/NBT supported.
• stonecutting <name> <ingredient> <result> [count] → result is a plain item id, so NBT on the result is not supported (vanilla serializer limitation).

Tags

create tag <name> <value1> [value2…] writes data/easycustomcraft/tags/items/<name>.json (replace:false). Values are items or tag: references (nested as #ns:path). The tag becomes usable everywhere as tag:easycustomcraft:<name>. Referencing an unknown tag elsewhere fails loudly (validated against the live tag manager).

Modded recipes (modded_craft)

Discovery

• types with no filter → one line per mod with a type count.
• types <filter> → matching type ids; a single match prints a full analysis: input/output field names, fluid usage, and every detected option with its observed values (e.g. heatRequirement = heated, superheated).
• Tab-completion after the output suggests all detected option keys, then their values.

Creation <type> <name> <input[,…]> <output> [count] [key=value…] The builder works by learning from a real recipe of that type and editing it:

1. Picks a template recipe of the type, preferring one in the type's own namespace and without conditions.
2. Strips conditions (so your recipe never inherits a forge:mod_loaded dependency on another mod).
3. Replaces item inputs with your list (fluid inputs from the template are kept); replaces the first item output with yours (secondary/fluid outputs kept).
4. Applies each key=value override onto the JSON (any top-level field; lists via commas).
5. Validates with the mod's own RecipeSerializer — invalid recipes are rejected with the mod's error, never written.
6. Writes + reloads, then reports the options kept from the example (e.g. heatRequirement=heated) so you can override them.

Scope & limits

• Best for 1→N item machines plus scalar/enum options; Create mixing-style recipes typically need ≥2 inputs or heat.
• Schemas are learned from loaded recipes only (Forge 1.20.1 serializers are not introspectable), so a field never used by any installed recipe won't be suggested — but you can still type any key=value manually.
• The full type schema is built in one pass over all recipes and cached (first types/tab may take a moment); string fields with >16 distinct values are treated as free-form.

Storage & runtime

• Each recipe is a data-pack file in <world>/datapacks/easycustomcraft/data/easycustomcraft/recipes/<name>.json.
• After every create/remove the mod runs a programmatic resource reload mirroring vanilla /reload, auto-enabling the pack on first use — changes are live immediately, no restart.
• This makes recipes inherently per world (single-player) or per server (dedicated).

Permissions & sides

• Root /ecc is public; list/preview are open. Everything under create, plus reload/remove, requires permission level 2 (OP).
• Custom command argument types (ingredient, ingredients) are registered with Forge, so the command tree syncs correctly. Install on the server for functionality and on the client for the GUI and command auto-complete.