AutoEMC — Complete Guide

Automatic, safe EMC value generation for ProjectE.

AutoEMC is a Forge mod that scans your modpack's items and recipes on startup, then fills in missing ProjectE EMC values automatically. Built for large "kitchen-sink" modpacks where manually pricing every item by hand isn't realistic.

1. The Big Picture: What AutoEMC Does

AutoEMC never wants to replace ProjectE — it just fills in the gaps. On startup it:

1. Checks what EMC values ProjectE already knows.
2. Reads all loaded recipes.
3. Tries to derive missing values from recipes it understands (this is always preferred over guessing).
4. Falls back to smart guesses only when no recipe path exists.
5. Writes everything out to ProjectE's value file, plus its own diagnostic logs.

The core rule in both versions: AutoEMC will not intentionally lower a value ProjectE or a pack author already set. It only fills gaps or (in 1.20.1) raises its own earlier fallback guesses when new recipe evidence justifies it.

2. How Values Get Solved (Recipe Solving)

This is the preferred method in both versions — solving prices from actual crafting recipes before ever guessing.

• If every ingredient in a recipe has a known EMC value, AutoEMC can calculate the output's value (roughly: total ingredient cost ÷ output count).
• 1.20.1 adds more nuance here:
  • Runs multiple solving "passes" (maxRecipePasses) so chains of recipes can resolve in stages.
  • Seeds raw/source materials with a starting fallback value so recipes that depend on them can still be solved, then re-solves afterward.
  • Can later reprice fallback outputs upward if a loaded recipe proves an item should cost more (postFallbackRecipeUpgrade).
  • Handles smithing transform recipes specially (upgraded tools/armor inherit value from their base item + upgrade material), but skips cosmetic smithing trims since they'd create noisy/misleading values.
  • When an ingredient has multiple matching options, it defaults to the safer, lower EMC value (allowRecipeValueIncrease can change this, but it's safer left off).
• 1.16.5 also uses bundled mapping/conversion data (from ProjectE Integration) as extra "recipe-like" edges, so things that aren't normal crafting recipes (like item-conversion mechanics) still count as solvable paths.

3. Fallback Pricing (When There's No Recipe)

If a recipe can't solve the price, AutoEMC falls back through several layers, roughly in this order:

1. Bundled baseline values — pulled from ProjectE Integration's shipped data (Botania, EnderIO, Mekanism, Create, and dozens of other mods).

2. Material/tag-based fallback — matches tags like forge:ingots/copper, forge:gems/diamond, forge:dusts/sulfur, forge:storage_blocks/iron, etc. A base material value gets multiplied by its form (e.g. a storage block ≈ 9 ingots, a nugget ≈ 1/9 of an ingot).

3. Rarity/tier-based fallback as a last resort:

   • 1.16.5: plain rarity-based fallback, with a "reverse-recipe floor" so raw materials can't end up cheaper than the processed goods made from them.

   • 1.20.1: adds rarity + stack size + durability fallback, plus a dedicated progression tier system for powerful modded items so they never get a cheap generic value:

     • Strong — e.g. Allthemodium, Wyvern-tier items
     • Very Strong — e.g. Vibranium, Draconic, Draconium, Awakened-tier items
     • OP — e.g. Unobtainium, Chaos/Chaotic, Infinity/Infinite, Creative-tier items

     Tier matches can trigger from the mod namespace, an exact item ID, or a keyword in the item's path.

Fallback is on by default in both versions (since it's what makes huge packs usable), but can be tightened or disabled for stricter setups.

4. NBT-Tagged Items

Both versions understand that some items (potions, enchanted books, material-tagged items) vary by their NBT data, not just their base ID.

• A pluggable NBT material resolver framework prices these based on their actual embedded material, instead of lumping every variant into one generic value.
• Built-in support for things like Avaritia singularities (priced from their material + a multiplier).
• Can run as a pre-scan pass and, in some cases, live during actual ProjectE conversions.
• maxNbtVariantsPerItem caps how many variants one item ID can generate, so one item can't explode into hundreds of entries in a huge pack.

5. Safety Features (Protecting the Economy)

Both versions share the same safety philosophy — don't let automated pricing wreck a pack's economy:

• Creative-only / no-recipe technical items are locked to 1 EMC by default, so they can never leak into survival as a source of infinite value.
• Large-drop protection blocks any single scan from crashing an already-priced item's value beyond a configurable ratio — instead it gets logged to a quarantine report rather than silently applied.
• Ownership tracking: AutoEMC keeps its own record of which values it generated, separate from ProjectE/pack-author values, so it knows what it's allowed to touch again later.
  • 1.16.5 specifically has an "ownership arbiter" that prevents ProjectE simply echoing back AutoEMC's last value from being mistaken for a manual override (which would otherwise delete AutoEMC's tracking of that entry).
• Never lowers ProjectE-owned values.
• Adaptive, batched scanning — works in small chunks across server ticks instead of freezing the server on startup, even with thousands of items.
• 1.20.1 additionally: skips rescanning if nothing changed since the last scan, and can require a minimum number of successfully-loaded recipes before it trusts normal fallback (catches broken recipe loading early).

6. Reports & Logs

Both versions write diagnostic files so you can audit exactly what happened and why:

• generated_entries.json — everything AutoEMC currently owns/generated.
• underpriced_inputs_report.json (1.16.5) — flags non-owned items that look priced too low relative to what they're used to craft.
• quarantined_drops.json (1.16.5) — value changes blocked for looking unsafe.
• autoemc-debug.log / autoemc-debug.previous.log (1.20.1) — main troubleshooting log, plus the log from the prior run.
• recipe_solve_state.json (1.20.1) — scan state, so an unchanged pack can skip unnecessary rescans.
• known_items.json (1.20.1) — tracked item registry state.
• config/ProjectE/custom_emc.json — the actual file ProjectE reads to apply EMC values.

Every generated value is tagged with its source (baseline, tag-material, rarity-fallback, reverse-recipe-floor, creative-no-recipe, etc.) so you can trace exactly how a number was reached.

7. Key Config Options

General

• enabled — master on/off switch.
• alwaysRescan (1.20.1) — scan every server start even if nothing changed.
• chatNotifications / chatVerbosity — scan messages in chat (0 = minimal, 2 = verbose).
• itemsPerTick / adaptiveBatchSizing / adaptiveBatchTargetMs — control scan batching/lag.

Recipe solving

• solveRecipes — turn recipe-derived values on/off.
• maxRecipePasses (1.20.1) — how many dependency-solving passes to run.
• allowRecipeValueIncrease — use the highest vs. lowest ingredient option (lowest/off is safer).
• useBundledProjectEMappingConversions / useMapperFramework — use bundled ProjectE-style conversion data as extra recipe edges.

Fallback

• useFallbackForUnsolvable — allow fallback pricing at all.
• useForgeTagFallback — use material tags before generic rarity fallback.
• useProjectEIntegrationBaselines — use bundled baseline values.
• giveCreativeNoRecipeItemsOneEmc — the 1-EMC safety floor for creative/no-recipe items.
• tagFallbackNamespaces — which tag namespaces to check (defaults: forge, mekanism, create).
• protectedCheapFallbackPatterns (1.20.1) — item ID fragments that should never get a cheap fallback value.

Safety

• largeDropProtectionThreshold / maxAllowedDropRatio — tune the large-drop guard.
• ownershipSmallDifferenceRatio — how much difference between AutoEMC's and ProjectE's values counts as "just noise."
• consistencyWarnMinRatio / consistencyWarnMinAbsoluteDelta (1.16.5) — thresholds for the underpriced-input report.

NBT

• scanNbtVariants — scan NBT-tagged item variants.
• maxNbtVariantsPerItem — cap variants generated per item ID.
• useNbtMaterialResolvers / useLiveNbtMaterialResolution — enable material-aware NBT pricing.
• nbtMaterialMultipliers — multipliers used by material-tagged NBT resolvers.

All of the above live in autoemc-common.toml.

8. Commands (1.20.1)

/autoemc rescan

Requires permission level 2. Forces a fresh scan immediately, without waiting for a server restart.

9. Build Info (1.20.1)

• Mod ID: autoemc
• Version: 2.0.0
• Build command: .\gradlew.bat clean build
• Output jar: build/libs/autoemc-2.0.0.jar

Pre-release smoke test checklist:

1. Launch with ProjectE + AutoEMC installed.
2. Confirm a scan-start message appears in the log.
3. Confirm no errors in latest.log or config/autoemc/autoemc-debug.log.
4. Confirm config/ProjectE/custom_emc.json gets written/updated.
5. Restart or /reload so generated values take effect.

Note: the first scan on a large pack can take 5+ minutes and may look like nothing is happening — it's working through items, recipes, and fallback logic. Wait for the completion message before assuming it's stuck.

10. Requirements Recap

1.16.5 build:

• Minecraft 1.16.5, Forge
• ProjectE (required)
• ProjectE Integration (required — both for baseline data and for its own integrations to function)

1.20.1 build:

• Minecraft 1.20.1, Forge 47.x, Java 17
• ProjectE (required, but no jar needs to be bundled — uses reflection/compat)
• ProjectE Integration (used as a baseline data source)

AutoEMC

Automatic, safe EMC value generation for ProjectE.

AutoEMC scans your modpack's item registry and recipes on startup and fills in missing ProjectE EMC values automatically, so you're not stuck with a Table of Existence full of "unlearnable" items. It's built for large kitchen-sink modpacks where manually pricing every item is unrealistic.

What it does

• Solves EMC from recipes first. AutoEMC walks your loaded recipes and derives EMC values from known inputs before ever guessing, so pricing stays internally consistent wherever possible.
• Falls back intelligently when there's no recipe. Items with no recipe path are priced using:
  • Bundled baseline values pulled directly from ProjectE Integration's shipped data (Botania, EnderIO, and dozens of other mods).
  • Material/tag-based fallback (ore, ingot, dust, block, raw forms, etc.), matched against forge, mekanism, create, and other configurable tag namespaces.
  • Rarity-based fallback as a last resort, with a reverse-recipe floor so cheap raw materials can't end up worth less than the processed goods made from them.
  • Understands NBT-tagged items. A pluggable NBT material resolver framework (with built-in support for things like Avaritia singularities) prices NBT-variant items based on their embedded material, instead of lumping them all into one generic value. This can run both as a pre-scan pass and as a live ProjectE conversion source that resolves on demand.
  • Protects the economy from itself. Several safety layers work together:
    • Creative-only and no-recipe technical items are locked to 1 EMC so they can never become a cheap source of infinite value if they somehow leak into survival.
    • A large-drop guard blocks any single-run change that would crash an already-priced item's value by more than a configurable ratio, and logs it to a quarantine report instead of silently applying it.
    • An ownership arbiter decides, item by item, whether AutoEMC should keep tracking a value or hand it off to ProjectE/a pack author's manual entry — so legitimate overrides are respected but ProjectE simply echoing AutoEMC's own last value can't cause ownership (and the entry) to be deleted.
  • Batched and adaptive. Every scan phase runs in small, adaptively-sized chunks across ticks instead of freezing the server on startup, even on packs with thousands of items.
  • Transparent. Every generated value is logged with its source (baseline, tag-material, rarity-fallback, reverse-recipe-floor, creative-no-recipe, etc.), and the mod writes out diagnostic reports each scan:
    • generated_entries.json — everything AutoEMC currently owns
    • underpriced_inputs_report.json — non-owned items that look priced too low relative to what they're used to craft
    • quarantined_drops.json — value changes that were blocked for looking unsafe

Requirements

• Minecraft 1.16.5, Forge
• ProjectE (required)
• ProjectE Integration (required — AutoEMC's bundled baseline data is sourced from it, and it must be present for those integrations to actually function in-game)

Configuration highlights

All of the following are configurable in autoemc-common.toml:

• scanNbtVariants — scan NBT-tagged item variants (on by default)
• useNbtMaterialResolvers / useLiveNbtMaterialResolution — enable material-aware NBT pricing, pre-baked and/or live
• giveCreativeNoRecipeItemsOneEmc — toggle the creative-item safety floor (on by default)
• largeDropProtectionThreshold / maxAllowedDropRatio — tune the large-drop guard
• ownershipSmallDifferenceRatio — how much difference between AutoEMC's and ProjectE's value counts as "just noise"
• tagFallbackNamespaces — which tag namespaces are checked during material fallback
• consistencyWarnMinRatio / consistencyWarnMinAbsoluteDelta — thresholds for the underpriced-input report

Notes

• AutoEMC never overwrites a value that's already correctly priced by ProjectE or a pack author unless it's confident the change is safe.
• If you're auditing a pack's economy, the debug log and JSON reports in config/autoemc/ are the fastest way to see exactly what was priced, how, and why.