Items¶

Ember Forge has its own item format, and also reads three others. You do not need any other plugin installed to define content.

The Ember Forge format¶

Files live in plugins/EmberForge/content/. One namespace per file — the file name is the namespace unless you set one.

# plugins/EmberForge/content/mypack.yml
namespace: mypack

items:

  ruby:
    name: "<#ff5f8f>Ruby"
    material: PAPER
    lore:
      - "<gray>Cut from a single ember."

  oak_stool:
    name: "<#c9a227>Oak Stool"
    material: PAPER
    model: furniture/oak_stool
    furniture:
      solid: true          # players cannot walk through it
      seat-height: 0.5     # makes it sittable
      sound: block.wood.place

Assets go beside it, under the namespace:

content/mypack/models/item/ruby.json
content/mypack/textures/item/ruby.png

Then /emberforge rebuild. No restart.

Fields¶

Key	Default	Meaning
`name`	the id, prettified	Display name. MiniMessage, so `<#ff5f8f>` and `<bold>` work
`material`	`PAPER`	The vanilla item the custom model rides on
`model`	`item/<id>`	Model path; namespaced (`mypack:item/ruby`) or bare
`lore`	none	Lore lines, MiniMessage
`texture`	none	A single texture; the flat item model is generated for you
`textures`	none	A face map (`north`..`down`); a full cube model is generated
`model-id`	assigned	Fix the custom-model-data number instead of letting it be allocated
`furniture.solid`	`false`	Give it a collision box
`furniture.seat-height`	none	Make it sittable; the number is where the player sits
`furniture.sound`	none	Sound played on placement

Because model defaults to item/<id>, most items need no model line at all.

Texture-only items¶

You do not have to write a model. Give a texture and Ember Forge generates one:

  emberwood_planks:
    name: "<#c9a227>Emberwood Planks"
    material: PAPER
    texture: block/emberwood_planks         # flat item, from one texture

  emberwood_log:
    name: "<#c9a227>Emberwood Log"
    material: PAPER
    textures:                               # a cube, one texture per face
      north: block/emberwood_log
      south: block/emberwood_log
      east: block/emberwood_log
      west: block/emberwood_log
      up: block/emberwood_log_top
      down: block/emberwood_log_top

Faces left out fall back to the first one given, so a plank only has to name one texture. This is how most block packs are authored, and it is the format to hand to an artist: textures in, no JSON required.

Model ids are allocated once and remembered

A new item gets the next free number from model-data-start, skipping anything in reserved-model-data. The assignment is written to model-ids.yml and reused from then on — otherwise every item already in a player's chest would change appearance on the next rebuild.

Formats it imports¶

Ember Forge also reads packs written for other plugins and normalises them into the same internal item, so a server can mix packs bought for different plugins. The other plugin does not need to be installed — Ember Forge reads its content folder, not its jar.

ItemsAdderOraxenNexo

info:
  namespace: mypack
items:
  ruby_sword:
    display_name: "<#ff5f8f>Ruby Sword"
    resource:
      material: IRON_SWORD
      model_path: "mypack:item/ruby_sword"
      model_id: 1042

Read from <pack>/configs/*.yml. Furniture is read from either Mechanics.furniture.* or behaviours.furniture*.

ruby_sword:
  displayname: "<#ff5f8f>Ruby Sword"
  material: IRON_SWORD
  Pack:
    model: "item/ruby_sword"
    custom_model_data: 10042

Read from <pack>/items/*.yml, assets from a sibling pack/, assets/, resourcepack/ or resource_pack/ folder.

Same layout as Oraxen. Nexo furniture click-actions are read for the parts Ember Forge can honour (sounds); the rest is ignored.

Translation keys¶

ItemsAdder packs often set a display name to a key rather than a name:

display_name: display-name-hand_gun

Ember Forge reads the pack's configs/dictionaries/en.yml and resolves it, so the item is called "Handgun" rather than display-name-hand_gun. A pack with no English dictionary keeps its key.

Giving items¶

/emberforge gui
/emberforge give <player> <namespace>:<id> [amount]
/emberforge info <namespace>:<id>
/emberforge id <namespace>:<id>

Items carry a persistent tag, so renaming or enchanting never loses their identity.

Duplicate ids¶

When two packs define the same namespace:id, the later one wins and says so:

[EmberForge] Duplicate item nieyels:ceiling_light — the copy from ITEMSADDER replaced the earlier one.

Silent replacement is how a pack loses items with no explanation, so it is always logged.

What is imported, and what you add¶

Ember Forge imports items, models, textures and furniture from other plugins' packs. It does not import their gameplay mechanics — weapon firing, food effects, abilities — because those ran inside the plugin the pack was written for, not in the pack.

You add them back in behaviours.yml, in a few lines, and they work on every item of that kind already in the world. See Abilities.