> ## Documentation Index
> Fetch the complete documentation index at: https://entities.lodemc.net/llms.txt
> Use this file to discover all available pages before exploring further.

# Mob Stats

> Every setting a mob can carry, what it defaults to, and the range it accepts.

A mob is declared in any `.yml` file under `plugins/LodeEntities/Mobs/`, one top-level key per mob (a folder per mob, with its model beside it, keeps things tidy). Only `base` is required; `model` is optional, and **every other field is optional too**. Leaving a field out means "keep the vanilla default", which is why most mobs are four lines long.

```yaml theme={null}
toast_king:
  model: toast
  base: zombie
  display: "&6&lToast King"
  health: 300
  scale: 2.0
```

## Identity

| Field | Type | Default | What it does |
| :- | :- | :- | :- |
| `base` | entity | **required** | The vanilla entity actually spawned. Must be spawnable. `player` spawns a mannequin, a player-shaped entity that can wear a `skin` (Minecraft 1.21.9 and newer). |
| `model` | text | no model | A `.bbmodel` (or `.ajmodel`) anywhere in `Mobs/`, by file name without the extension. Omit it for a plain vanilla mob: stats and effects still apply. |
| `display` | text | the entity's own name | Name shown above the mob. `&` colour codes work. |
| `name-visible` | on/off | on when `display` is set | Off shows the name only when you look at the mob. Ignored when there is no `display`. |
| `faction` | text | none (neutral to everything) | Which side it's on. Relations live in `factions.yml` — see [Factions & Threat](https://entities.lodemc.net/factions-threat.md). |
| `child` | mob id | a vanilla baby of the base entity | The mob two of these produce when they [breed](#breeding). |
| `type` | `mob` or `npc` | `mob` | `npc` makes it an [NPC](https://entities.lodemc.net/npcs.md), which unlocks `dialog` and `look`. |
| `dialog` | dialog id | none | **NPCs only.** The [conversation](https://entities.lodemc.net/dialogs.md) a right-click starts. |
| `look` | on/off | off | **NPCs only.** Turns its head toward the nearest player within 8 blocks. |
| `skin` | player name, uuid or png | the default mannequin skin | **`base: player` only.** What it wears; see [NPCs that look like players](https://entities.lodemc.net/npcs.md#npcs-that-look-like-players). |

## Stats

| Field | Range | Default | What it does |
| :- | :- | :- | :- |
| `health` | `1`–`1024` | the entity's own | Max health in points. 1 heart = 2. |
| `damage` | `0`–`2048` | the entity's own | Melee damage in points. |
| `armor` | `0`–`30` | the entity's own | Armor points, on top of any worn gear. |
| `speed` | `0`–`1024` | the entity's own | Walk speed. Vanilla mobs sit around `0.2`–`0.3`. |
| `knockback-resistance` | `0`–`1` | the entity's own | Fraction of knockback ignored. `0` takes it all, `1` is immovable. |
| `follow-range` | `0`–`128` | the entity's own | Blocks within which it notices and pursues a target. |
| `attack-knockback` | `0`–`10` | the entity's own | Extra knockback its melee hits apply, on top of the base amount. |
| `scale` | `0.05`–`64` | `1` | Visual size multiplier for the model. On a model-less mob it sets the vanilla scale attribute instead. Stacks with `/le spawn`'s own `scale` argument. |

> [!NOTE]
>
> Stat fields only apply to living bases. An `armor_stand` base ignores `health`, `damage`, `armor` and `speed`; the flags below still work on anything.

## Behaviour and presence

| Field | Default | What it does |
| :- | :- | :- |
| `ai` | on | Off freezes the brain — it stands where it is put and never acts. What a statue or a cutscene prop wants. |
| `gravity` | on | Off and it floats where it is. |
| `invulnerable` | off | Immune to every kind of damage. |
| `persistent` | the entity's own | On = never despawns on its own. |
| `collidable` | on | Off lets entities walk straight through it. |
| `silent` | off | On stops its vanilla noises. |
| `glowing` | off | Outline visible through walls. |
| `invisible` | off | Hides the entity itself. A model still shows, so this is for **model-less** mobs — and for showing held or worn items with no visible owner. |
| `can-pick-up-items` | the entity's own | Whether it collects items it walks over, and may then wear them. |

## Sections

Some fields are sections rather than single values:

| Field | What it is |
| :- | :- |
| [`equipment`](mob-equipment) | What it wears and holds, per slot, with drop chances. |
| [`aging`](mob-aging) | What this mob grows into, and after how long. |
| [`effects`](overview) | Effect lines fired on their triggers. Extra list keys on the mob are its own [skills](https://entities.lodemc.net/named-effects.md). |
| [`animation-speed`](#animation-speed) | How fast its model's automatic animations play. |
| [`egg`](#spawn-eggs) | How its spawn egg looks. |
| [`spawners`](spawners) | Spots in the world that keep a population of this mob alive. |
| [`pet`](pets) | What it's like once a player owns it: taming, following, levels, riding. Premium only. |

## Animation speed

How fast the model's automatic animations play, by name: `idle`, `walk`, `idle_fly`, `walk_fly`, `spawn`, `death`, `damage`, `jump`.

```yaml theme={null}
warhog:
  base: pig
  model: warhog
  animation-speed:
    walk: 1.5      # half as fast again
    idle: 0.8
```

Walking still speeds up and slows down with Speed and Slowness on top of this. `/le reload` applies it to mobs already in the world, without respawning them.

## Spawn eggs

A mob's egg (from `/le gui`, the editor, or one in flight) looks like a vanilla spawn egg in the mob's own colours, **read off its model's textures** when the pack is built: the colour most of the model is made of becomes the egg, its most noticeable other colour the spots. It stays a real egg, and throwing it is what spawns the mob.

Override it with an `egg:` block. The first of these that is set wins:

```yaml theme={null}
lodefer:
  base: blaze
  egg:
    model: mypack:item/lodefer_egg   # any item model, from any resource pack
    texture: lodefer_egg.png         # a png beside this file, baked into the pack
    colors: ["#6b6f78", "#b48ae0"]   # body, then spots, for the generated egg
```

* `colors` takes effect on the next egg made; no pack rebuild needed.
* `texture` must sit in `Mobs/`, beside the mob's file or under it. Aim for 16x16; other sizes are padded to a power-of-two square. `/le reload` bakes it in.
* `model` is used as is: the pack that defines it is yours to load.
* A mob without a model gets its base entity's vanilla spawn egg. A base with no spawn egg of its own gets a chicken egg with a glint.
* Clients older than 1.21.4 see a chicken egg either way.

## Breeding

Feed two of a mob and what appears is **the mob it declares as its `child`**, not a vanilla baby:

```yaml theme={null}
hog:
  base: pig
  model: hog
  child: piglet     # two hogs make a piglet, not a baby pig

piglet:
  base: pig
  model: piglet
  aging: { grows-into: hog, after: 20m }
```

Without this, a custom mob's lifecycle leaks back to vanilla at the one moment it matters most: two of your modelled, named, statted hogs are fed wheat and out comes a plain baby pig, because the base entity is all vanilla knows about. Declaring the child as a **mob** gives the baby its own model, stats and effects — and lets it [grow](https://entities.lodemc.net/mob-aging.md) back into its parent on the ordinary timer.

* **Both parents must be the same mob.** Crossing two different custom mobs has no answer anyone could predict, and neither does crossing one with a vanilla animal — those keep vanilla's own behaviour.
* The experience the vanilla baby would have dropped is dropped anyway. The parents have already paid for it.
* A plugin that forbids breeding — region protection, a farm limiter — has its say first, and no mob is spawned into a "no".
* Leave `child` out and vanilla decides, which for a modelled mob means a plain baby of the base entity.

## A full example

```yaml theme={null}
flame_knight:
  model: flame_knight
  base: wither_skeleton
  display: "&cFlame Knight"
  health: 120
  damage: 12
  armor: 8
  speed: 0.28
  knockback-resistance: 0.6
  follow-range: 48
  faction: undead
  persistent: true
  can-pick-up-items: false
  equipment:
    hand: netherite_sword
    head: { item: wither_skeleton_skull, drop-chance: 1 }
  effects:
  - message{m=&cYou dare?} +onInteract @target
```

## Editing without opening a file

Every field on this page except `effects` and `skin` can be set in game from the [Entities menu](https://entities.lodemc.net/gui.md): left-click a mob to open its editor, left-click a stat to type a value, right-click a stat to clear it back to the default. **Equipment** opens a screen of its own where you dress the mob from your inventory. Changes are written straight back into the YAML the mob came from, so the file stays the source of truth.

## Notes

* Field names are read with `-` and `_` interchangeably, and case-insensitively.
* Values are checked when they load: a number out of range, an entity that can't be spawned, and a misspelled field are all reported by [`/le debug`](debug) with the file and the reason, rather than silently ignored.
* A mob whose `model` isn't loaded (deleted, renamed, or skipped for its file name) is **disabled**: it disappears from `/le gui`, autocomplete and the API, and commands say why. Put the model back and `/le reload` re-enables it.
* The mob id may contain letters, digits, `_`, `-` and `.`, but no spaces: it is typed as one command argument.
* Field names follow MythicMobs, simplified: `base` is `Type`, `display` is `Display`, `speed` is `Options.MovementSpeed`, `persistent` is the opposite of `Options.Despawn`. A MythicMobs mob file converts on load; see [MythicMobs](https://entities.lodemc.net/mythicmobs.md).
* Ids are **global**. Two mobs in different files — or different subfolders — still cannot share an id, and you get a duplicate warning if they do.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.