Entities

Skills

Skills are what a custom mob does besides walk and bite: a ground slam every few seconds, minions when it drops below half health, a poison aura, a volley of fireballs, a second phase where it gets faster.

You write them as MythicMobs skill lines, one per line under the mob's skills:. A Skills: block copied from a MythicMobs mob file runs here as it is, as long as it uses only what this page lists. You don't need MythicMobs installed. Needs RP Engine 0.2.53 or newer.

Mobs made in Studio bring the abilities you gave them there, and run the same way.

The example below is a boss in entities/ of a content folder. Each line under skills: says what to do, at whom (@...), when (~on...) and if (?...). The next section takes a line apart.

# entities/bosses.yml
golem_king:
  type: ZOMBIE
  model: bosses:golem
  name: "&6Golem King &7{hp}/{max_hp}"
  health: 300
  boss-bar: {color: YELLOW}
  stance: calm                    # the stance it starts in (optional)
  skills:                         # or Skills:, as MythicMobs spells it
  - message{m="&6<caster.name>&f: Who disturbs my rest?"} @PlayersInRadius{r=30} ~onSpawn
  - skill{s=GroundSlam} @self ~onTimer:120 ?targetwithin{d=8}
  - leap{velocity=150} @target ~onTimer:100 ?distance{d=6to20} 0.6
  - skill{s=CallTheGuard} @self ~onDamaged =50%
  - potion{type=SLOW;duration=60;level=2} @trigger ~onAttack 0.3
  - command{c="say <caster.name> has fallen to <trigger.name>"} @self ~onDeath

A skill line#

mechanic{option=value;...} @targeter{...} ~trigger ?condition{...} <health> chance

Only the mechanic is required. Everything after it is optional and can come in any order:

Names are case-insensitive, and MythicMobs' short names work: @PIR for @PlayersInRadius, a= for amount=, d= for damage=. A number may be a range, amount=2to5, and a new one is picked each time.

Every mechanic also takes these:

delay 20 on a line of its own is different: it pauses the rest of the list for 20 ticks.

The long form#

If you'd rather not write a line, each entry can be a YAML map instead. It is turned into the same line:

  skills:
  - mechanic: leap            # or do:
    args: {velocity: 150}
    target: "@target"         # or targeter:
    trigger: onTimer:100
    if: ["distance{d=6to20}"] # or conditions:
    health: "<50%"
    chance: 0.6

Both forms can sit in one list. A line with : in it that YAML read as a map (an unquoted message{m="Boss: hi"}) is put back together for you.

Metaskills#

A metaskill is a named list of lines in skills/, in MythicMobs' own file shape, so several mobs can share it and one line can call it:

# skills/bosses.yml
GroundSlam:
  Cooldown: 8                     # seconds, per mob
  Conditions:                     # tested on the caster
  - stance{s=calm}
  TargetConditions:               # each target must pass
  - isplayer
  Skills:
  - animate{a=attack} @self
  - delay 10                      # ticks; the rest of the list waits
  - vfx{id=bosses:shockwave} @selflocation
  - damage{a=6} @PlayersInRadius{r=6}
  - throw{velocity=12;velocityY=6} @PlayersInRadius{r=6}

Call one with skill{s=GroundSlam} (also skill:GroundSlam, metaskill, meta). A bare name is looked for in the mob's own pack first, then in any pack; otherpack:GroundSlam names another pack's. randomskill{skills=a,b,c} casts one of several at random.

In Conditions: lists a condition may carry an action after it:

Enrage:
  Conditions:
  - health{h=<25%} power 1.5
  Skills:
  - damage{a=8} @target

Triggers#

Targeters#

Every targeter also takes:

Radius targeters leave out the mob itself unless targetself=true, and always leave out spectators.

Mechanics#

Amounts are multiplied by the skill's power (see Levels and the power condition action). A mechanic that needs an entity skips a place; one that needs a place uses an entity's.

Damage and health#

Effects on the target#

Movement#

Summons, fighting and signals#

Shooting and explosions#

Looks, sound and text#

Everything else#

Plugins can add their own mechanics, conditions and targeters through the Plugin API, the way MythicMobs' add-ons do. Theirs usually carry a prefix: myplugin:smite{damage=6}.

Conditions#

On a line, ? tests the mob, ?! must fail, and ?~ tests whatever set the skill off. In a metaskill, Conditions:, TargetConditions: and TriggerConditions: say which.

Placeholders#

Text in a skill (a message, a title, a command, a bar's value) can carry:

{caster_hp} is the same thing in RP Engine's own spelling, and MythicMobs' escapes work (<&sc> for ;). A mob's name: can show {hp}, {max_hp}, {hp%}, {stance} and {level}; see Its name.

Stances and phases#

A stance is a word the mob carries: calm, angry, phase2. stance: on the mob sets the first one, setstance{stance=angry} changes it, and ?stance{s=angry} (or ?!stance{...}) picks the lines that run in it. It shows in the name as {stance}.

A phase is a health line with =:

= does not re-arm when the mob heals (a phase skill often heals it). It is remembered while the server runs, so a restart lets a phase fire once more. Together, a stance and a phase make a second phase:

  skills:
  - setstance{stance=enraged} @self ~onDamaged =50%
  - skill{s=Enrage} @self ~onDamaged =50%
  - damage{a=4} @target ~onTimer:60 ?stance{s=enraged}

Cooldowns, delays and repeats#

• Cooldown: on a metaskill and cooldown= on a line are seconds, per mob. skilloncooldown{s=Name} tests one, and OnCooldownSkill casts something else meanwhile.
• delay 20 on its own line pauses the rest of the list. delay=20 on a mechanic delays only that line.
• repeat=4;repeatInterval=10 runs a line five times, ten ticks apart.

Auras#

An aura runs skills on its target for a while: damage over time, a slow that ticks, a buff.

- aura{auraName=venom;duration=100;interval=20;onTick=[ - damage{a=1} - particles{p=slime} ]} @target ~onAttack 0.3

It runs onStart once, onTick every interval ticks for duration ticks, then onEnd. Each of those is an inline list ([ - line - line ]) or a metaskill's name. There is one aura of a name per target: casting it again restarts its clock rather than stacking a second one. charges= ends it after that many ticks of it. It ends early when the target dies or leaves.

Projectiles#

projectile fires a shot that can carry skills of its own: onStart where it leaves, onTick at every step, onHit on each living thing it touches, onEnd where it stops.

It is invisible unless onTick draws it (particles{p=flame}, MythicMobs' way) or it is given a look: bullettype=item;item=minecraft:fire_charge (any pack's item), or bullettype=vfx;vfx=zoo:fireball (a looping VFX). missile turns toward the entity it was fired at, more sharply the lower its inertia (1.5). At most 256 fly at once across the server, and none outlives a minute or a reload.

Threat tables#

threat-table: true on a mob (MythicMobs' Modules: {ThreatTable: true} reads the same) makes it fight whoever has hurt it most. Damage dealt to it is threat, and it turns to a new target only when that one holds more than 110% of its current target's threat, so two players trading hits don't spin it round.

Somebody who dies, leaves, goes into creative or out of twice its follow range drops off the table, and an empty table is a mob out of combat (~onDropCombat). threat, taunt and clearthreat change it; @ThreatTable and @RandomThreatTarget aim at it.

Variables#

A mob can keep variables: variables: {phase: 1} on the mob sets them as it spawns, setvariable and variableadd change them, <caster.var.phase> (or {caster_var_phase}) prints one, and variableequals and variableinrange test one. They live on the mob (var=phase or var=caster.phase), or on a target mob with var=target.phase. A variable is kept while the server runs, not across a restart.

Limits and debugging#

A few limits stop a mistake (say, a mob that summons itself on spawn) turning into lag. Each says so once in the console when it is hit:

A mob's waiting skills stop when it dies (except its ~onDeath skills, which finish where it fell) and on /rp reload.

A line that can't run is a load warning naming its file and place, and only that line is skipped; the rest of the mob loads:

bosses/entities/bosses.yml: golem_king.skills[3]: There is no mechanic explode.

To see what a mob is actually doing, turn on skills.debug in config.yml. It logs every line as it runs and what it aimed at. It is noisy, so turn it off again afterwards.

skills:
  debug: true

Worked examples#

A boss that slams and summons#

Every six seconds, if a player is close, it rears up and slams the ground. At half health, once, it calls three guards and they join the fight.

# entities/bosses.yml
golem_king:
  type: IRON_GOLEM
  model: bosses:golem
  name: "&6Golem King &7{hp}/{max_hp}"
  health: 300
  boss-bar: {color: YELLOW, style: SEGMENTED_10}
  animations: {idle: idle, walk: walk, attack: attack, hurt: hurt, death: death}
  skills:
  - skill{s=GroundSlam} @self ~onTimer:120 ?playerwithin{d=8}
  - skill{s=CallTheGuard} @self ~onDamaged =50%
 
golem_guard:
  type: ZOMBIE
  model: bosses:guard
  health: 30
  faction: golems

# skills/bosses.yml
GroundSlam:
  Cooldown: 6
  Skills:
  - animate{a=slam} @self
  - delay 10
  - vfx{id=bosses:shockwave} @selflocation
  - sound{s=entity.generic.explode;v=1;p=0.6} @selflocation
  - damage{a=8} @PlayersInRadius{r=6}
  - throw{velocity=10;velocityY=6} @PlayersInRadius{r=6}
 
CallTheGuard:
  Skills:
  - message{m="&6<caster.name>&f: Guards!"} @PlayersInRadius{r=30}
  - summon{type=golem_guard;amount=3;radius=4} @selflocation
  - heal{a=50} @self

summon names the guard bare because it is in the same pack. The guards take up the boss's target as they spawn, and @children reaches them later.

A ranged caster with a phase two#

It keeps its distance and throws small fireballs. At half health, once, it changes stance: it goes faster, starts firing homing missiles, and limps.

# entities/casters.yml
ember_witch:
  type: SKELETON
  model: casters:witch
  name: "&cEmber Witch &7[{stance}]"
  health: 120
  stance: calm
  ranged: {projectile: small_fireball, damage: 4, range: 20}
  animations: {idle: idle, walk: walk, attack: cast, hurt: hurt, death: death}
  skills:
  - setstance{stance=burning} @self ~onDamaged =50%
  - message{m="&cThe witch's robes catch fire!"} @PlayersInRadius{r=24} ~onDamaged =50%
  - speed{multiplier=1.4;duration=12000} @self ~onDamaged =50%
  - defaultstate{state=walk;animation=limp} @self ~onDamaged =50%
  - skill{s=EmberMissile} @target ~onTimer:80 ?stance{s=burning} ?targetwithin{d=24}

# skills/casters.yml
EmberMissile:
  Cooldown: 3
  Skills:
  - animate{a=cast} @self
  - missile{v=8;md=30;hR=0.6;vR=0.6;inertia=1.2;onTick=[ - particles{p=flame;a=3} ];onHit=[ - damage{a=6} - ignite{ticks=60} ]} @target

The =50% lines each run once, together, the first time its health drops to half. The name shows its stance, so players can see the change.

A poison aura mob#

A slow mob that poisons everybody standing near it, and hurts whoever hits it.

# entities/swamp.yml
bog_lurker:
  type: ZOMBIE
  model: swamp:lurker
  name: "&2Bog Lurker"
  health: 50
  speed: 0.7
  skills:
  - aura{auraName=bog;duration=60;interval=20;onTick=[ - potion{type=POISON;duration=40;level=1} - particles{p=item_slime;a=6} ]} @PlayersInRadius{r=4} ~onTimer:60
  - damage{a=2} @trigger ~onDamaged 0.5
  - particles{p=item_slime;a=20} @selflocation ~onDeath

Casting the aura on a player who already has it restarts its clock, so standing next to the lurker keeps you poisoned and walking away lets it run out.

What is not supported#

Each of these is a load warning naming the line:

• variable maths and scopes other than the mob's (variableMath, skill. and global. variables);
• switch and foreach;
• custom AI goals (AIGoalSelectors): pick type for behaviour, and move it with the mechanics;
• disguise and onHear;
• composite conditions (a && b): write two conditions instead;
• riding a mob as a player (mountmodel);
• ImmunityTables and Trades;
• command{asop=true} run as an op player.

Bringing a whole MythicMobs mob across? See Porting your MythicMobs mobs.