NeoOrigins 2.0 action_on_event Event Reference

neoorigins:action_on_event listens for one of the event keys below. When the event fires, the power’s entity_action (for action-style events) or modifier (for MOD_* events) runs with the event’s context in scope.

Source of truth for the key list: EventPowerIndex.Event. Every key in the enum has a live EventPowerIndex.dispatch(...) call site. Keys that earlier drafts exposed without a dispatch site have been removed rather than left as silent no-ops; see the Removed keys section at the bottom for the two that were dropped (and their replacements).

Event shape 

{
  "type": "neoorigins:action_on_event",
  "event": "<KEY>",
  "condition": { ... },          // optional — entity-side gate
  "block_condition": { ... },    // optional — block-side gate (block events only)
  "entity_action": { ... },      // for action-style events
  "modifier": { ... }            // for MOD_* events; chains with other registered modifiers
}

event is the lowercase enum name (e.g. "kill", "mod_exhaustion"). condition is an EntityCondition evaluated against the player before the action / modifier runs. Use it for origin:power_active, item-in-hand, fluid-in-eyes, and similar gates. entity_action and modifier may both be set on one power; the dispatcher only calls whichever matches the site’s call shape.

block_condition is an optional gate that only applies when the event is block-shaped (block_break, block_place, block_use, bonemeal). The dispatch BlockPos is extracted from the event context and the predicate is evaluated before the action runs. Supports block / id / tag fields, e.g. { "type": "neoorigins:block", "id": "minecraft:stone" }. On non-block events the field is silently ignored. Use this instead of (or in addition to) condition when you want to filter by what was broken/placed/used:

{
  "type": "neoorigins:action_on_event",
  "event": "block_break",
  "block_condition": { "type": "neoorigins:block", "id": "minecraft:stone" },
  "entity_action": {
    "type": "neoorigins:drop_items",
    "items": [{ "item": "minecraft:emerald", "chance": 0.05 }]
  }
}

The event’s context is published to ActionContextHolder for the duration of the dispatch so context-aware action verbs (neoorigins:damage_attacker, neoorigins:cancel_event, neoorigins:food_item_in_tag, …) can read it without needing to be parameterised at JSON authoring time.

cancel_event support

neoorigins:cancel_event as the entity_action vetoes the underlying game event, but only where NeoForge exposes a cancellable event:

  • Cancellable: death (lethal blow undone; a player still at 0 HP is left at 1 HP, totem-style), kill (spares the victim, same 1-HP patch), hit_taken, attack, land (negates fall damage), projectile_hit, item_use, food_eaten, effect_applied, block_break, block_place, block_use, entity_use, villager_interact, breed, tame, bonemeal.
  • Not cancellable (post-hoc or uncancellable NeoForge event; cancel_event is a silent no-op): jump, item_use_finish, food_finished, item_pickup, craft_item, smelt_item, enchant_item, anvil_repair, trade_completed, advancement_earned, wake_up, respawn, dimension_change, climb, tick, gained, lost, chosen, power_activated, and all mod_* modifier events.

Action-style events

These run a side-effect action against the player actor when fired. Register via entity_action.

attack

Fires when the player attacks a living entity (pre-damage).

Context: the target LivingEntity itself. Bientity conditions on the power can read it as the target.

Dispatch site: CombatPowerEvents.onAttackEntity (hooks AttackEntityEvent).

Typical use: apply mining fatigue / slow to anything you hit, charge a rage meter, spawn a visual shockwave.

hit_taken

Fires when the player takes damage (post-cancel, before final apply).

Context: HitTakenContext(amount, source). The amount is the vanilla- adjusted damage and the DamageSource is the original source. Action verbs like neoorigins:damage_attacker read amount for amount-ratio thorns-style retaliation.

Dispatch site: CombatPowerEvents.onLivingDamage (LivingIncomingDamage victim branch).

Typical use: thorns/counter-damage, defensive-cooldown triggers, hurt-noises, panic-mode buffs.

hit_dealt

Fires on the attacker when the player deals damage to a living entity: the attacker-side mirror of hit_taken. Unlike attack (which fires pre-damage), this fires after damage modifiers are applied, so it sees the actual amount landed.

Context: HitDealtContext(amount, target, source). amount is the final post-modifier damage dealt, target is the LivingEntity that was hit, and source is the DamageSource. The neoorigins:hit_dealt_amount condition gates on the most recent damage the player dealt.

Dispatch site: CombatPowerEvents attacker-side HIT_DEALT dispatch (fed by the HIGH-priority onLivingDamage hook, attacker branch).

Typical use: lifesteal / blood-tithe healing scaled to damage dealt, combo counters, on-hit resource gain, big-hit screen shake.

kill

Fires when the player kills a living entity.

Context: KillContext(killed), the LivingEntity that just died. Bientity / entity-type conditions can filter on it.

Dispatch site: CombatPowerEvents.onLivingDeath (killer = ServerPlayer branch).

Typical use: bloodthirst healing, kill-streak counters, soul-capture mechanics.

death

Fires when the player themself dies.

Context: none (null).

Dispatch site: CombatPowerEvents.onLivingDeath (dying-player branch, fires before the killer branch).

Typical use: revival sigils (paired with neoorigins:cancel_event), last-stand explosions, insurance payouts.

block_break

Fires when the player successfully breaks a block (post-cancel).

Context: the BlockEvent.BreakEvent itself, readable by neoorigins:cancel_event and any verb that reflects on the event object.

Dispatch site: WorldPowerEvents.onBlockBreak.

Typical use: XP from ores, mining-sound replacement, silk-touch emulation.

block_place

Fires when the player places a block. Cancellable via neoorigins:cancel_event (vetoes the placement).

Context: the BlockEvent.EntityPlaceEvent.

Dispatch site: WorldPowerEvents.onBlockPlace.

Typical use: place-and-enchant, build-mode dust particles, builder-class XP.

item_use

Fires when the player right-clicks to use an item. Two kinds of item are covered:

  • Held-use items (food, potions, bows, shields, spyglasses, tridents; anything with a use duration): fires at use start, when the right-click hold begins.
  • Instant-use items (fireworks, ender pearls, snowballs, eggs, splash potions, fire charges; anything used in a single click): fires on the right-click itself, whether aimed at air or at a block.

Context: the held ItemStack, plus the cancellable interaction event, so neoorigins:cancel_event vetoes the use, and an item_condition can target a specific item (e.g. only minecraft:firework_rocket).

Dispatch site: CompatEventPowers.onItemUseStart (LivingEntityUseItemEvent.Start, held-use items), CompatEventPowers.onRightClickItem (RightClickItem, instant items in air), and CompatEventPowers.onRightClickBlockUse (RightClickBlock, instant items aimed at a block). All run after the prevent_item_use gate, only if not cancelled.

Typical use: rev-up animations, charging sounds, start cooldowns; or, with cancel_event, blocking an item outright (e.g. preventing firework use). For block-aimed instant items, only the item’s use is denied; the block’s own interaction (opening a chest, flipping a lever) still works.

Note: instant-use coverage is broader than a held-use start. An item_use handler with no item_condition now also fires on snowballs, ender pearls, etc. Add an item_condition to scope it to the items you care about.

respawn

Fires when the player respawns (after origin re-sync and modify_player_spawn teleport).

Context: none.

Dispatch site: PlayerLifecycleEvents.onPlayerRespawn.

Typical use: gift-on-respawn, status-effect restore, hunger top-up.

tick

Fires once per server tick for every online player.

Context: none.

Dispatch site: PlayerLifecycleEvents.onPlayerTick (PlayerTickEvent.Pre).

Typical use: anything periodic. Prefer the cheaper neoorigins:toggle / neoorigins:active_self patterns where possible. tick runs 20 times a second for every player.

dimension_change

Fires when the player changes dimension.

Context: none. If you need the dimension ID, query player.level().dimension() inside the action.

Dispatch site: PlayerLifecycleEvents.onPlayerChangedDimension.

Typical use: dimension-gated buffs, portal-sickness effects, re-equip starter gear on Nether entry.

climb

Fires once per server tick while the player is on a climbable block (ladder, vine, scaffolding, …).

Context: none. Query player state inside the action for finer detail.

Dispatch site: PlayerLifecycleEvents.onPlayerTick (gated on player.onClimbable(), fired right after the generic tick).

Typical use: spider-class climb-speed buffs, wall-cling stamina drain, fall-immunity-while-climbing. Like tick, this runs every tick the gate is met. Keep the action cheap and gate hard with condition.

jump

Fires when the player jumps.

Context: none.

Dispatch site: CombatPowerEvents.onLivingJump (LivingEvent.LivingJumpEvent filtered to ServerPlayer).

Typical use: double-jump priming, jump-boost particles, stamina drain.

projectile_hit

Fires when a projectile owned by the player hits something (entity or block).

Context: ProjectileHitContext(projectile, result), the projectile entity and the HitResult. Check result.getType() for ENTITY / BLOCK / MISS.

Dispatch site: CombatPowerEvents.onProjectileImpact.

Typical use: homing arrows, projectile-converts-to-lightning, ranged debuff application.

craft_item

Fires when the player crafts an item in a crafting grid (table or inventory).

Context: CraftContext(stack), the crafted result ItemStack.

Dispatch site: CraftingPowerEvents.onItemCrafted (PlayerEvent.ItemCraftedEvent).

Typical use: artisan-class craft XP, recipe-discovery rewards, craft-and-enchant.

smelt_item

Fires when the player removes a smelted item from a furnace / smoker / blast furnace output.

Context: CraftContext(stack), the smelted result ItemStack.

Dispatch site: CraftingPowerEvents.onItemSmelted (PlayerEvent.ItemSmeltedEvent).

Typical use: smelting XP bonus, auto-quench effects, cook-class progress.

enchant_item

Fires when the player applies enchantments at an enchanting table (post-apply).

Context: CraftContext(stack), the freshly-enchanted ItemStack.

Dispatch site: CraftingPowerEvents.onItemEnchanted (PlayerEnchantItemEvent).

Typical use: arcane-class enchant rituals, lapis refund, bonus-curse application. Distinct from mod_enchant_level, which changes the offered level before the player commits.

anvil_repair

Fires when the player takes the repaired / combined output from an anvil.

Context: CraftContext(stack), the finished ItemStack.

Dispatch site: CraftingPowerEvents.onAnvilRepair (AnvilCraftEvent.Post). In 26.1 the legacy AnvilRepairEvent was removed; the post-craft hook is now AnvilCraftEvent.Post, whose getOutput() carries the result.

Typical use: smith-class repair XP, durability bonus on repair, free-naming perks. Distinct from mod_anvil_cost, which only scales the XP cost preview.

bonemeal

Fires when the player applies bone meal to a block. Cancellable via neoorigins:cancel_event (the bone meal is not consumed and nothing grows).

Context: BlockInteractContext(pos, state, event), the bonemealed block’s position and state; carries the underlying cancellable BonemealEvent. block_condition filters by block type.

Dispatch site: CraftingPowerEvents.onBonemeal (BonemealEvent).

Typical use: druid-class growth particles, biome-spread effects, bonemeal-as-fertilizer-XP. Distinct from mod_bonemeal_extra, which scales the number of extra growth applications.

breed

Fires when two animals the player bred produce a baby. Cancellable via neoorigins:cancel_event (vetoes the baby spawn).

Context: EntityInteractContext(child, event), the spawned baby LivingEntity; carries the underlying cancellable BabyEntitySpawnEvent.

Dispatch site: WorldPowerEvents.onBabyEntitySpawn (BabyEntitySpawnEvent, gated on a causing ServerPlayer). Dispatched before the twin_breeding gate, so a breed power and twin_breeding can coexist.

Typical use: rancher-class breeding rewards, bonus-baby chance hooks, breeding-streak counters.

tame

Fires when an animal is tamed by the player. Cancellable via neoorigins:cancel_event (the taming fails).

Context: EntityInteractContext(animal, event), the tamed LivingEntity; carries the underlying cancellable AnimalTameEvent.

Dispatch site: WorldPowerEvents.onAnimalTame (AnimalTameEvent, gated on getTamer() instanceof ServerPlayer).

Typical use: beastmaster-class taming buffs, minion registration, tame particle effects. For minion-tracking integration see the dedicated tame_mob power.

food_eaten

Fires at item-use start for any stack carrying a vanilla FOOD data component. Cancellable via neoorigins:cancel_event.

Context: FoodContext(stack, event), the food ItemStack plus the underlying LivingEntityUseItemEvent.Start (so cancel_event can veto the eat). neoorigins:food_item_in_tag reads the stack.

Dispatch site: MovementPowerEvents.onItemUseStart (only dispatched when the stack has a FOOD component).

Typical use: vegetarian / carnivore restrictions, allergen damage, bonus-effect-on-eat.

food_finished

Fires when the player finishes eating a food item (post-eat). Not cancellable: the food has already been consumed. This is distinct from food_eaten which fires at eat-start and can cancel the eat.

Also synthetically fired by EdibleItemPower after a successful bite, so custom edible items trigger the same post-eat hooks.

Context: FoodContext(stack, event), the consumed food ItemStack. Context-aware conditions like neoorigins:food_item_in_tag and neoorigins:food_item_id read the stack.

Dispatch site: InteractionPowerEvents.onItemUseFinish (LivingEntityUseItemEvent.Finish, only dispatched when the stack has a FOOD component).

Typical use: post-eat nutrition bonuses, food-specific buffs, bonus saturation for certain food types.

advancement_earned

Fires when the player earns an advancement.

Context: AdvancementContext(id), the advancement’s Identifier.

Dispatch site: PlayerLifecycleEvents.onAdvancementEarned (AdvancementEvent.AdvancementEarnEvent). Folded into the existing advancement handler, so it fires for every earned advancement. Gate with condition if you only care about specific ones.

Typical use: milestone rewards, achievement-gated power unlocks, progression-tied buffs.

trade_completed

Fires when the player completes a trade with a villager or wandering trader.

Context: TradeContext(offer), the MerchantOffer that was traded.

Dispatch site: InteractionPowerEvents.onTradeCompleted (TradeWithVillagerEvent).

Typical use: merchant-class trade XP, haggle-streak counters, trade-completion sound / particle.

villager_interact

Fires when the player right-clicks a villager or wandering trader, a narrower alias for entity_use that only matches AbstractVillager targets. Fired after the generic entity_use so a power can target either granularity. Cancellable via neoorigins:cancel_event (vetoes the interaction before the trade screen opens).

Context: EntityInteractContext(target, event), the villager / trader LivingEntity; carries the underlying cancellable PlayerInteractEvent.EntityInteract event.

Dispatch site: InteractionPowerEvents.onEntityUse (the AbstractVillager branch).

Typical use: charisma discounts, villager-specific dialogue hooks, reputation gestures.

gained

Fires when a power has just been granted to the player.

Context: the power’s Identifier ID (as a raw Object).

Dispatch site: ActiveOriginService.applyOriginPowers (after onGranted + PowerGrantedEvent).

Typical use: welcome-message broadcasts, one-shot starter equipment, origin-pick particle effect. Fires every origin change. Use condition to gate on a specific origin.

lost

Fires when a power has just been revoked from the player.

Context: the power’s Identifier ID.

Dispatch site: ActiveOriginService.applyOriginPowers (after onRevoked + PowerRevokedEvent).

Typical use: clean-up rituals, revoke-gained items, farewell message.

chosen

Fires when the player picks an origin from the selection screen (ChooseOriginPayload).

Context: the newly-chosen origin’s Identifier.

Dispatch site: NeoOriginsNetwork.ChooseOriginPayload handler.

Typical use: first-choice welcome flow, origin-lock gates, server-wide announcement. Fires on every pick. Gate on hadAllOrigins if you only want the first time.

wake_up

Fires when the player wakes from sleeping.

Context: none.

Dispatch site: PlayerLifecycleEvents.onPlayerWakeUp.

Typical use: well-rested buff, dream-power cooldown reset.

land

Fires when the player lands after a fall.

Context: the fall distance as a boxed Float.

Dispatch site: MovementPowerEvents.onLivingFall (runs after the prevent_action: FALL_DAMAGE gate).

Typical use: landing shockwave, impact-damage scaling, parkour streak reset.

block_use

Fires when the player right-clicks a block (general: runs for every RightClickBlock event, including cancelled ones from other mods’ gates). Cancellable via neoorigins:cancel_event (vetoes the interaction).

Context: BlockInteractContext(pos, state, event), carries the underlying cancellable RightClickBlock event.

Dispatch site: InteractionPowerEvents.onBlockUse.

Typical use: right-click enchant, block-specific rituals, class-lock interactions.

entity_use

Fires when the player right-clicks a living entity. The narrower villager_interact alias fires immediately after, only when the target is a villager or wandering trader. Both are cancellable via neoorigins:cancel_event (vetoes the interaction, e.g. blocking villager trading for an origin).

Context: EntityInteractContext(target, event), carries the underlying cancellable PlayerInteractEvent.EntityInteract event. The breed, tame and bonemeal dispatches share this pattern and are likewise cancellable.

Dispatch site: InteractionPowerEvents.onEntityUse (filtered to LivingEntity targets).

Typical use: healing touch, taming-by-class, entity-hug particle, trade-lock origins (villager_interact + cancel_event).

villager_interact

Fires when the player right-clicks a villager or wandering trader (AbstractVillager covers both), a narrower alias of entity_use, fired immediately after it so a power can target either granularity. Cancellable via neoorigins:cancel_event (vetoes the interaction before the trade screen opens).

Context: EntityInteractContext(target, event), carries the underlying cancellable PlayerInteractEvent.EntityInteract event.

Dispatch site: InteractionPowerEvents.onEntityUse.

Typical use: trade-lock origins (pillager-friendly origins that villagers refuse to deal with), reputation hooks.

breed

Fires when the player causes a baby animal to spawn (feeding two parents). Fires regardless of any twin_breeding power. Cancellable via neoorigins:cancel_event (vetoes the baby spawn).

Context: EntityInteractContext(child, event). The target is the newborn AgeableMob; carries the underlying cancellable BabyEntitySpawnEvent.

Dispatch site: WorldPowerEvents.onBabyEntitySpawn.

Typical use: shepherd-class bonuses on breeding, sterile-origin breeding bans (cancel_event).

tame

Fires when the player tames an animal (wolf, cat, horse, parrot, etc.; any AnimalTameEvent). Distinct from the tame_mob power, which tames via its own active-ability pipeline. Cancellable via neoorigins:cancel_event (the taming fails).

Context: EntityInteractContext(animal, event), carries the underlying cancellable AnimalTameEvent.

Dispatch site: WorldPowerEvents.onAnimalTame.

Typical use: beastmaster buffs on tame, feral origins that animals refuse to bond with (cancel_event).

bonemeal

Fires when the player applies bone meal to a block. Distinct from mod_bonemeal_extra, which only scales the extra-application count. Cancellable via neoorigins:cancel_event (the bone meal is not consumed and nothing grows). Cancelling wins over mod_bonemeal_extra: a granted extra never revives an interaction a power has refused.

Context: BlockInteractContext(pos, state, event), the bonemealed block; carries the underlying cancellable BonemealEvent. Supports block_condition like the other block events.

Dispatch site: CraftingPowerEvents.onBonemeal.

Typical use: druid growth side-effects, blighted origins that kill instead of grow (cancel_event + replacement action).

item_pickup

Fires when the player picks up an item entity off the ground.

Context: the ItemStack that was picked up.

Dispatch site: InteractionPowerEvents.onItemPickup (ItemEntityPickupEvent.Post).

Typical use: coin-magnet XP, allergy damage, auto-sort hooks.

item_use_finish

Fires when the player finishes using an item (distinct from ITEM_USE which fires at use-start). Also synthetically fired by EdibleItemPower after a successful bite.

Context: the finished ItemStack.

Dispatch site: InteractionPowerEvents.onItemUseFinish (LivingEntityUseItemEvent.Finish) and InteractionPowerEvents.onRightClickItem (for EdibleItemPower consumes).

Typical use: post-eat buffs, empty-bottle return, drink-finish sound.

power_activated

Fires when another power on the same player is successfully activated: an active power fired past its cooldown / hunger / resource gates, or a toggle power flipped (either direction; pair with a power_active condition on the toggled power if you only want one direction). Compat-layer (Route B) actives fire per dispatched attempt, since their gating lives inside the compat consumer and exposes no success signal.

Context: EventPowerIndex.PowerActivatedContext, carries the activated power’s id.

Dispatch sites: AbstractActivePower.onActivated (success branch), AbstractTogglePower.onActivated, CompatPower.onActivated, all via EventPowerIndex.dispatchPowerActivated.

Filter (power, optional): a single power id or an array of ids; the action only fires when the activated power’s id matches. Omit to fire on any activation.

Re-entrancy: if a power_activated listener’s action itself activates a power (e.g. via a command), that nested activation does not re-dispatch power_activated; A→B→A loops are cut at the first level. The nested activation itself still happens.

{
  "type": "neoorigins:action_on_event",
  "event": "power_activated",
  "power": "neoorigins:ground_slam",
  "entity_action": {
    "type": "neoorigins:execute_command",
    "command": "say Ground slam unleashed!"
  }
}

Typical use: announce ability use in chat, chain a secondary effect onto another ability, build combo systems (resource gain on each activation).

effect_applied

Fires when a MobEffect is about to be added to the player, after vanilla EffectImmunityPower / EntityGroupPower immunity rules but before the effect lands. Cancelling with neoorigins:cancel_event denies the application (calls setResult(DO_NOT_APPLY) on the underlying MobEffectEvent.Applicable).

Context: EventPowerIndex.EffectAppliedContext, carries the MobEffectInstance, its registry id, and the cancellable event.

Dispatch site: CombatPowerEvents.onMobEffectApplicable (MobEffectEvent.Applicable).

Filters: the action_on_event config accepts two optional pre-dispatch filters that work only on this event:

  • effect: a single registry id (e.g. spore:mycelium_ef)
  • effect_tag: a TagKey<MobEffect> (e.g. #minecraft:harmful; leading # optional)

If both are set they OR-match. If neither is set the action fires for every effect that reaches dispatch.

Post-cleanse grace (immunity_ticks, optional, default 0): when the action successfully cancels an EFFECT_APPLIED event AND immunity_ticks > 0, opens a per-effect-id grace window. Subsequent EFFECT_APPLIED dispatches for the same effect short-circuit to DO_NOT_APPLY until the window closes, skipping the user’s condition entirely. Lets pack authors smooth out probabilistic cancels: a successful 50% random_chance cleanse with immunity_ticks: 40 means the player is fully immune for 2 seconds before the next re-roll. The window max-merges across powers (multiple cleanses take the longest expiry, not the latest) and is cleared on logout.

Typical use: infection resistance (probabilistic cancel via random_chance + cancel_event + grace window); class-specific antidote behaviour; sound/particle reactions to incoming buffs.

Modifier-style events (return a float)

These chain modifiers on a vanilla float value. Base value enters, each modifier transforms, result goes back to vanilla. Register via modifier (or a list of them).

mod_exhaustion

Scales hunger exhaustion (which drives food drain).

Context: null. The base value is the unscaled exhaustion delta.

Dispatch site: FoodDataMixin.causeFoodExhaustion (movement, damage, mining, …) and FoodDataTickMixin.addExhaustion (regen-tick exhaustion). Both routes use the same event so a single MOD_EXHAUSTION power covers both.

Typical use: draconic 1.5× drain, feline 1.3× drain, avian 0.25× drain.

mod_natural_regen

Scales the amount the player heals from natural food-based regeneration.

Context: null. Base value is event.getAmount() from LivingHealEvent.

Dispatch site: WorldPowerEvents.onLivingHeal.

Typical use: fast/slow regen class modifiers, regen-on-sunlight, low- HP healing buff.

mod_trade_price

Per-player adjustment of a merchant offer’s cost-A count. The chained result is treated as the new absolute count (clamped to [1, maxStackSize]) and folded into vanilla’s specialPriceDiff channel (the same knob Hero of the Village and villager reputation use), so it stacks on top of natural discounts and shows correctly on both client and server.

Context: TradeContext(offer), the MerchantOffer. Base value is the currently-displayed cost-A count.

Dispatch site: AbstractVillagerTradePriceMixin (TAIL of AbstractVillager.setTradingPlayer, applied on trade-screen open). The mixin’s HEAD inject resets the prior contribution on close so the delta never compounds across repeated opens of the same wandering trader.

Typical use: charisma-class cheaper trades, cursed-class price hikes, faction-discount perks.

mod_craft_amount

Scales the count of the assembled crafting-grid result. The chained result is treated as the new count (clamped to [1, maxStackSize]) and written to the result slot in place, so vanilla’s later broadcastChanges syncs it to the client.

Context: the result ItemStack. Base value is the recipe’s natural output count.

Dispatch site: CraftingMenuCraftAmountMixin (RETURN of the static CraftingMenu.slotChangedCraftingGrid, which covers both the 3×3 table and the 2×2 inventory grid). Server-only in 26.1 (the method’s level parameter is a ServerLevel).

Typical use: artisan-class double-output, efficient-crafting perks, resource-multiplier classes.

mod_harvest_drops

Multiplies extra-drop count when the player kills an animal.

Context: the killed LivingEntity. Base value is 1.0f; final value is rounded and extraCopies = Math.max(0, Math.round(value) - 1).

Dispatch site: CombatPowerEvents.onLivingDrops (filtered to Animal victims).

Typical use: hunter class double-drops, butcher bonus wool/leather.

mod_knockback

Scales incoming knockback strength for the player as victim. A result ≤ 0 cancels the knockback entirely.

Context: null. Base value is event.getStrength().

Dispatch site: CombatPowerEvents.onLivingKnockBack.

Typical use: heavy-frame knockback resistance, stone-armour no-push, mid-air combat anti-knockback.

mod_potion_duration

Multiplies the duration of status effects newly added to the player. Re-entry guarded so the replacement addEffect doesn’t recurse.

Context: the MobEffectInstance being added (readable for effect-specific gating from conditions). Base value is 1.0f.

Dispatch site: CombatPowerEvents.onMobEffectAdded.

Typical use: longer potions, shorter debuffs, witch-class effect amplifier scaling (use with care: this scales duration, not amplifier).

mod_bonemeal_extra

Adds extra bonemeal applications when the player uses bonemeal on a block. Base value is 0f (vanilla behaviour is one application total) and the final value is Math.round(result), clamped at zero.

A result above zero makes the handler take the interaction over rather than adding to it. It cancels the event, which suppresses vanilla’s own application, performs result + 1 applications so the suppressed one is still accounted for, consumes one bone meal itself and reports success. Half-participating is not an option here: growing the block from inside the event can turn vanilla’s own live-world validity check false, and NeoForge then discards every block change the handler made without ever telling the client.

The takeover is deliberately narrow, so vanilla is left completely alone unless all of the following hold:

  • the modifier chain resolved to at least one extra, and
  • the block was a valid bonemeal target when the event was constructed, that is before any power ran, and
  • no power cancelled the event, from either this dispatch or bonemeal.

The first of the applications keeps vanilla’s isBonemealSuccess roll, which is a random chance on crops, since it stands in for the vanilla growth. The extras do not consult that roll.

Context: the BonemealEvent itself.

Dispatch site: CraftingPowerEvents.onBonemeal.

Typical use: druid / forester class, 2× / 3× growth per bonemeal.

mod_enchant_level

Modifies the level shown on an enchanting-table slot. Note: the EnchantmentLevelSetEvent has no player reference, so NeoOrigins runs a spatial query for players within 8 blocks of the table and dispatches to each. First player whose modifier changes the level wins.

Context: the EnchantmentLevelSetEvent. Base value is the vanilla level as a float.

Dispatch site: CraftingPowerEvents.onEnchantmentLevelSet.

Typical use: arcane class +3 enchant levels, cursed class -2.

mod_crafted_food_saturation

Additive saturation bonus applied to any food item freshly crafted or smelted by the player. Base value is 0f; final bonus is added to the item’s existing saturation field. Values ≤ 0 are ignored.

Context: the resulting ItemStack.

Dispatch site: CraftingPowerEvents.onItemCrafted and onItemSmelted (via boostFoodIfCook).

Typical use: chef class, crafted/smelted food gives +0.2 saturation.

mod_anvil_cost

Multiplies the XP-level cost of an anvil repair / combine.

Context: the AnvilUpdateEvent. Base value is 1.0f; final cost is max(1, (int)(originalCost * value)).

Dispatch site: CraftingPowerEvents.onAnvilUpdate.

Typical use: artisan / smith class 0.5× anvil cost, cursed class 2×.

mod_teleport_range

Scales the range of built-in neoorigins:active_teleport (the replacement for the legacy teleport_range_modifier).

Context: null. Base value is the power config’s declared range.

Dispatch site: ActiveTeleportPower.execute.

Typical use: ender class, +4 blocks teleport distance, cursed class halved.

Note: only affects the built-in active-teleport power. Ender pearls and mod teleports are not routed through this event.

mod_fall_damage

Scales the fall-damage multiplier when the player lands. Chains on the event’s current multiplier so it stacks with feather-falling and similar effects. A result ≤ 0 (or non-finite) zeroes fall damage; the final value is clamped to ≥ 0.

Context: the LivingFallEvent. Base value is event.getDamageMultiplier().

Dispatch site: MovementPowerEvents.onLivingFall (runs after the land dispatch and the prevent_action: FALL_DAMAGE gate).

Typical use: acrobat-class reduced fall damage, heavy-class increased impact, partial fall mitigation that stacks with vanilla effects. For a full no-fall immunity, prefer prevent_action: FALL_DAMAGE.

Removed keys

Two keys that earlier drafts exposed were dropped because a better-fitting mechanism already covers them; exposing a second, redundant handler would only invite divergent behaviour:

  • mod_break_speed → use the break_speed_modifier power (backed by the vanilla player.block_break_speed attribute, which auto-syncs to the client; the event route silently no-op’d because PlayerEvent.BreakSpeed fires client-side for the local player).
  • mod_xp_gain → use the origins:modify_xp_gain power type (aliases apace: / apoli: / apugli:), parsed by the Apoli compat layer in OriginsCompatPowerLoader.parseNumericModifier into the NumericModifierRegistry XP_GAIN path with full Apoli modifier math (addition + multiply_base / multiply_total). There is no native neoorigins: spelling for this one; the compat type is the supported route, and it is not deprecated.

Cross-reference