Merge commit 'eafa8990074b1e21be4b7b68593c7eb21362dcf8' into feat/bw-finalized

Author: ArikSquad

pvp/.github/README.md

@@ -39,6 +39,28 @@ ProjectileSystem.install(polyp);
 
 Requires the published `net.minestom:minestom` artifact (see `minestomVersion` in the build) — no Minestom fork.
 
+## Custom player class
+
+Polyp installs an `OptimizedPlayer` provider (self-echo filtering, per-client compat state, the dispatcher opt-out
+that shard domain ticking needs). To use your own player class, extend it and swap the factory — every
+`instanceof OptimizedPlayer` gate in the library keeps matching:
+
+```java
+public class MyPlayer extends OptimizedPlayer {
+    public MyPlayer(PlayerConnection connection, GameProfile profile) { super(connection, profile); }
+}
+
+polyp.playerFactory = MyPlayer::new;   // read per-connect, so before or after init() both work
+```
+
+If you override `tick` or `refreshCurrentChunk`, call super — they carry the guards that keep a domain-ticked
+player from double-ticking in the global dispatcher.
+
+Running a different provider entirely (`installPlayerProvider = false`, or another plugin owns it): packet-level
+compat (meta fix, pose interception, item rewrites, `PlayerConfig`) is inert for those players, but the plain-API
+behaviors still apply — sprint strip on sneak/use, movement collision revert, swim dampening — through
+profile-resolved fallback state. Domain ticking skips uncovered players instead of double-ticking them.
+
 ## Status
 
 Pre-release. APIs move; presets are updated as captures refine the measured values.

pvp/src/main/java/io/github/term4/polyp/Polyp.java

@@ -24,6 +24,8 @@
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventNode;
+import net.minestom.server.network.player.GameProfile;
+import net.minestom.server.network.player.PlayerConnection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
@@ -32,6 +34,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiFunction;
 
 /**
  * Main initialization class for the library: server-level options (trackers, metaFix), the node tree
@@ -51,12 +54,15 @@ public final class Polyp {
     /** Removes the pose-change stutter (sneak/sprint/...) 1.9+ clients show under high ping. Requires {@link #installPlayerProvider}. */
     public boolean metaFix = true;
     /**
-     * Installs the {@code OptimizedPlayer} provider and scoped {@code PlayerConfig} application. Independent of
-     * {@link #metaFix}. Disable only if you set your own player provider; extend {@code OptimizedPlayer} there to keep
-     * PlayerConfig support.
+     * Installs {@link #playerFactory} as the player provider + scoped {@code PlayerConfig} application. To customize
+     * the player class set {@link #playerFactory} instead of disabling this - the packet-level compat keys on it.
      */
     public boolean installPlayerProvider = true;
 
+    /** Builds each connecting player. Swap for an {@code OptimizedPlayer} subclass to keep the whole
+     *  {@code instanceof}-gated compat/fixes layer; read per-connect, so setting it after init works too. */
+    public BiFunction<PlayerConnection, GameProfile, ? extends OptimizedPlayer> playerFactory = OptimizedPlayer::new;
+
     private final EventNode<@NotNull Event> root = EventNode.all("polyp:root");
     private final EventNode<@NotNull Event> apiEvents = EventNode.all("polyp:api-events");
     private EventNode<@NotNull Event> trackersNode;
@@ -119,14 +125,14 @@ private void doInit() {
 
         if (metaFix && !installPlayerProvider) {
             LOG.warn("metaFix is enabled but installPlayerProvider is not - the meta fix needs the OptimizedPlayer"
-                    + " provider and will be inert (set your own provider extending OptimizedPlayer).");
+                    + " provider and will be inert (keep the provider on and set playerFactory instead).");
         }
         if (metaFix) MetaFix.installListeners();
+        CompatMovement.install(this); // plain server API: covers foreign-provider players, so not provider-gated
         if (installPlayerProvider) {
-            MinecraftServer.getConnectionManager().setPlayerProvider((conn, profile) ->
-                    new OptimizedPlayer(conn, profile));
+            // reads the field per-connect, not bound at init: a factory set late still takes effect
+            MinecraftServer.getConnectionManager().setPlayerProvider((conn, profile) -> playerFactory.apply(conn, profile));
             PlayerConfigApplier.install(this);
-            CompatMovement.install(this);
             // inert unless CompatConfig.disableOffhand
             CompatOffhand.install(this);
             // inert unless CompatConfig.blockPlaceReach

pvp/src/main/java/io/github/term4/polyp/fx/Fx.java

@@ -48,8 +48,7 @@ private Fx() {}
     public static final Key THROW_SNOWBALL = Key.key("polyp:throw_snowball");
     public static final Key THROW_EGG = Key.key("polyp:throw_egg");
     public static final Key THROW_PEARL = Key.key("polyp:throw_pearl");
-    /** Pearl landed and moved its thrower. 1.8 has none ({@code EntityEnderPearl} is silent; {@code mob.endermen.portal}
-     *  is the enderman's own), so this is a server addition there - unregistered in {@link #vanilla18()}. */
+    /** Pearl landed and moved its thrower. 1.8 has no pearl sound, so {@link #vanilla18()} leaves it unregistered. */
     public static final Key PEARL_TELEPORT = Key.key("polyp:pearl_teleport");
     /** Fire charge thrown from the hand. */
     public static final Key THROW_FIREBALL = Key.key("polyp:throw_fireball");
@@ -62,6 +61,8 @@ private Fx() {}
     public static final Key ARROW_HIT = Key.key("polyp:arrow_hit");
     /** Arrow struck a target - the hit-marker "ding" to the SHOOTER only. Unregistered by default; a PvP preset registers it. */
     public static final Key ARROW_HIT_PLAYER = Key.key("polyp:arrow_hit_player");
+    /** A burning entity doused by water (1.8 {@code random.fizz}); heard by viewers, never the doused player. */
+    public static final Key FIRE_EXTINGUISH = Key.key("polyp:fire_extinguish");
     /** TNT ignited (primed TNT spawned). */
     public static final Key TNT_PRIME = Key.key("polyp:tnt_prime");
     /** The big explosion flash; played for power >= 2 (the 1.8 client's hugeexplosion-vs-explode gate). */
@@ -106,6 +107,9 @@ public static void play(@NotNull Services services, @NotNull Key key, @NotNull F
                 // 1.8 item pickup
                 .register(ITEM_PICKUP, ctx -> ctx.sound(SoundEvent.ENTITY_ITEM_PICKUP, Sound.Source.PLAYER, 0.2f,
                         jitterPitch(0.7f) * 2.0f))
+                // 1.8 random.fizz 0.7F / 1.6F +- 0.4 dual-rand
+                .register(FIRE_EXTINGUISH, ctx -> ctx.viewerSound(SoundEvent.ENTITY_GENERIC_EXTINGUISH_FIRE,
+                        Sound.Source.NEUTRAL, 0.7f, 0.6f + jitterPitch(0.4f)))
                 .register(THROW_SNOWBALL, throwSound(SoundEvent.ENTITY_SNOWBALL_THROW, Sound.Source.NEUTRAL))
                 .register(THROW_EGG, throwSound(SoundEvent.ENTITY_EGG_THROW, Sound.Source.PLAYER))
                 .register(THROW_PEARL, throwSound(SoundEvent.ENTITY_ENDER_PEARL_THROW, Sound.Source.NEUTRAL))
@@ -136,11 +140,8 @@ public static void play(@NotNull Services services, @NotNull Key key, @NotNull F
         return ctx -> ctx.sound(SoundEvent.ENTITY_PLAYER_TELEPORT, Sound.Source.PLAYER, 1.0f, 1.0f);
     }
 
-    /**
-     * Hypixel BEDWARS only: the pearl landing reaches the whole lobby at full volume, however far away the thrower
-     * is - an audible tell that someone pearled. SkyWars and their other modes keep the positional
-     * {@link #pearlTeleport()}, so this belongs on a per-mode registry, not the shared Hypixel one.
-     */
+    /** Hypixel BEDWARS only (their other modes stay positional): the landing reaches the whole game at full
+     *  volume regardless of distance, so it rides a per-mode registry, not the shared Hypixel one. */
     public static @NotNull FxHandler pearlTeleportGameWide() {
         return ctx -> ctx.globalSound(SoundEvent.ENTITY_PLAYER_TELEPORT, Sound.Source.PLAYER, 1.0f, 1.0f);
     }

pvp/src/main/java/io/github/term4/polyp/fx/FxContext.java

@@ -83,11 +83,8 @@ public void sourceSound(@NotNull SoundEvent sound, @NotNull Sound.Source src, fl
             p.sendPacket(new SoundEffectPacket(sound, src, source.getPosition(), volume, pitch, ThreadLocalRandom.current().nextLong()));
     }
 
-    /**
-     * The sound to EVERY player in the world at full volume, positioned at each listener so distance never
-     * attenuates it - a game-wide announcement rather than a thing that happened somewhere (Hypixel BedWars
-     * pearls). One shared seed, so variant-picking sounds still pick the same variant for everyone.
-     */
+    /** The sound to every player in the world, positioned at each LISTENER so distance never attenuates it.
+     *  One shared seed: variant-picking sounds pick the same variant for everyone. */
     public void globalSound(@NotNull SoundEvent sound, @NotNull Sound.Source src, float volume, float pitch) {
         long seed = ThreadLocalRandom.current().nextLong();
         for (Player p : world.players()) {

pvp/src/main/java/io/github/term4/polyp/mechanics/attribute/catalog/enchant/FireAspect.java

@@ -5,7 +5,7 @@
 import io.github.term4.polyp.mechanics.attribute.combat.HitContext;
 import io.github.term4.polyp.mechanics.attribute.combat.OnHit;
 import io.github.term4.polyp.mechanics.damage.DamageSystem;
-import io.github.term4.polyp.util.tick.TickScaler;
+import io.github.term4.polyp.mechanics.damage.types.burning.Ignite;
 import net.kyori.adventure.key.Key;
 
 import java.util.List;
@@ -30,8 +30,7 @@ private static final class FireAspectSource extends ItemSource implements OnHit
 
         @Override public void onHit(HitContext ctx) {
             if (ctx.level() <= 0) return;
-            // real-time duration: Minestom decrements fireTicks at server TPS
-            ctx.victim().setFireTicks(TickScaler.duration(ctx.victim(), ctx.level() * TICKS_PER_LEVEL, DamageSystem.KEY));
+            Ignite.ignite(ctx.victim(), ctx.level() * TICKS_PER_LEVEL, DamageSystem.KEY);
         }
     }
 }

pvp/src/main/java/io/github/term4/polyp/mechanics/damage/DamageSystem.java

@@ -100,6 +100,8 @@ public final class DamageSystem implements MechanicsModule {
     private final DamageCalculator calc;
     private final DamageTypeRegistry registry;
     private final Services services;
+
+    public Services services() { return services; }
     private final EventNode<@NotNull Event> node;
 
     public DamageSystem(Polyp polyp, DamageConfig config) {
@@ -111,14 +113,9 @@ public DamageSystem(Polyp polyp, DamageConfig config) {
         this.registry = new DamageTypeRegistry(this, polyp).registerVanillaDefaults();
         // window stamps ride the victim's per-instance clock; the TickState future-guard misses a coinciding long-lived instance
         this.node.addListener(PlayerSpawnEvent.class, e -> clearDamageWindow(e.getPlayer()));
-        // Vanilla sends the hurt sound to everyone EXCEPT the victim (1.8 EntityHuman.makeSound -> the
-        // sendPacketNearby overload that skips them; modern Player.playSound passes itself as the excluded
-        // player). The victim's own client covers it: EntityPlayerSP/LocalPlayer override playSound to play
-        // directly, so the animation packet they also receive is enough. A REMOTE entity's hurt sound is NOT
-        // predicted - that playSound sinks into a no-op in both eras (1.8 RenderGlobal.playSound is an empty
-        // stub, modern ClientLevel.playSeededSound only fires when the excluded player is the local one).
-        // Minestom sends it to viewers AND self, so the victim heard it twice; re-emit to viewers only rather
-        // than dropping it, or an attacker never hears the hit land.
+        // vanilla sends the hurt sound to everyone EXCEPT the victim, whose own client predicts it
+        // (EntityPlayerSP/LocalPlayer override playSound; a remote entity's playSound is a client no-op in both
+        // eras). Minestom sends viewers AND self - re-emit to viewers only, or the victim doubles / attackers hear nothing
         this.node.addListener(EntityDamageEvent.class, e -> {
             SoundEvent sound = e.getSound();
             if (sound == null || !e.shouldAnimate()) return;
@@ -275,6 +272,9 @@ public DamageOutcome apply(DamageSnapshot snap) {
             living.setTag(LAST_DAMAGE, Math.max(event.stored(), amount));
             living.setTag(LAST_DAMAGE_TYPE, type);
             applyDamage(living, type, finalSnap, applied, replacementSilent);
+            // vanilla runs the post-hit enchant effects on ANY landed hit - an overdamage refresh included
+            // (EntityHuman.attack applies fire aspect whenever damageEntity returns true)
+            dispatchWeaponOnHit(living, finalSnap);
             fireDamageApplied(finalSnap, applied, DamageOutcome.OVERDAMAGE);
             return DamageOutcome.OVERDAMAGE;
         }

pvp/src/main/java/io/github/term4/polyp/mechanics/damage/types/burning/BurningTicker.java

@@ -1,5 +1,7 @@
 package io.github.term4.polyp.mechanics.damage.types.burning;
 
+import io.github.term4.polyp.fx.Fx;
+import io.github.term4.polyp.fx.FxContext;
 import io.github.term4.polyp.mechanics.damage.DamageConfigResolver;
 import io.github.term4.polyp.mechanics.damage.DamageSnapshot;
 import io.github.term4.polyp.mechanics.damage.DamageSystem;
@@ -27,7 +29,7 @@
  */
 final class BurningTicker implements EnvironmentalTickProducer {
 
-    private static final BurningTicker INSTANCE = new BurningTicker();
+    static final BurningTicker INSTANCE = new BurningTicker();
     /** Consecutive ticks standing in the current fire/lava contact (reset on leave). */
     private static final Tag<Integer> CONTACT_TICKS = Tag.Transient("polyp:burn-contact-ticks");
     private static final int DEFAULT_BURN_INTERVAL = 20;
@@ -72,10 +74,14 @@ public void tick(LivingEntity living, DamageSystem sys) {
             else if (block.compare(Block.FIRE) || block.compare(Block.SOUL_FIRE)) contact[2] = true;
             return contact[0] && contact[1] && contact[2];
         });
-        boolean wet = contact[0];
+        boolean wet = contact[0]; // water contact only: vanilla's isWet also counts rain, which nothing here models
         boolean inHazard = contact[1] || contact[2];
 
-        if (wet && living.getFireTicks() > 0) living.setFireTicks(0);
+        if (wet && living.getFireTicks() > 0) {
+            living.setFireTicks(0);
+            // viewers only, like 1.8's makeSound: the doused player hears nothing (their client forces fireTicks 0)
+            Fx.play(sys.services(), Fx.FIRE_EXTINGUISH, FxContext.of(living));
+        }
 
         if (!inHazard) {
             living.removeTag(CONTACT_TICKS);
@@ -103,11 +109,10 @@ private static void contact(DamageSystem sys, LivingEntity living, DamageType ty
             Integer ignite = bc.igniteTicks(ctx);
             if (ignite != null && ignite > 0) {
                 int invul = resolvedInvul(sys, ctx, bc);
-                // fire duration + warmup are real-time windows; Minestom decrements fireTicks at server TPS, so scale them (identity at 20)
                 int warmup = TickScaler.duration(living, bc.resolveIgniteWarmup(ctx, invul), DamageSystem.KEY);
-                int scaledIgnite = TickScaler.duration(living, ignite, DamageSystem.KEY);
                 boolean pin = living.getFireTicks() > 0 || contactTicks >= warmup;
-                if (pin && living.getFireTicks() < scaledIgnite) living.setFireTicks(scaledIgnite);
+                // every vanilla ignition routes through setOnFire, so Fire Protection cuts this one too
+                if (pin) Ignite.ignite(living, ignite, DamageSystem.KEY);
             }
         }
 

pvp/src/main/java/io/github/term4/polyp/mechanics/damage/types/burning/Ignite.java

@@ -0,0 +1,35 @@
+package io.github.term4.polyp.mechanics.damage.types.burning;
+
+import io.github.term4.polyp.item.Enchants;
+import io.github.term4.polyp.mechanics.attribute.catalog.enchant.ProtectionEnchant;
+import io.github.term4.polyp.util.tick.TickScaler;
+import net.kyori.adventure.key.Key;
+import net.minestom.server.entity.LivingEntity;
+import net.minestom.server.item.ItemStack;
+
+/**
+ * Vanilla {@code Entity.setOnFire}: Fire Protection cuts the duration 15% per level (highest armor piece),
+ * and a shorter burn never overwrites a longer one - Minestom's raw {@code setFireTicks} does both wrong.
+ */
+public final class Ignite {
+
+    private Ignite() {}
+
+    /** {@code vanillaTicks} pre-scale; {@code scaleKey} is the calling system's TickScaler key. */
+    public static void ignite(LivingEntity victim, int vanillaTicks, Key scaleKey) {
+        int prot = maxFireProtection(victim);
+        if (prot > 0) vanillaTicks -= (int) Math.floor(vanillaTicks * prot * 0.15f);
+        int scaled = TickScaler.duration(victim, vanillaTicks, scaleKey);
+        if (victim.getFireTicks() < scaled) victim.setFireTicks(scaled);
+    }
+
+    // 1.8 EnchantmentManager.a: the HIGHEST level across equipment, not the sum
+    private static int maxFireProtection(LivingEntity victim) {
+        int max = 0;
+        for (ItemStack armor : new ItemStack[]{
+                victim.getHelmet(), victim.getChestplate(), victim.getLeggings(), victim.getBoots()}) {
+            max = Math.max(max, Enchants.level(armor, ProtectionEnchant.FIRE_PROTECTION.key()));
+        }
+        return max;
+    }
+}

pvp/src/main/java/io/github/term4/polyp/mechanics/projectile/entities/ManagedProjectile.java

@@ -75,6 +75,7 @@ protected boolean onHit(@NotNull Entity target) {
             case DESTROY -> { fireImpact(target); return true; }
         }
 
+        beforeEntityDamage(target);
         DamageSystem.DamageOutcome result = applyDamageAndKnockback(target, ev);
         // didn't land: the InvulnResponse picks by why - IMMUNE (creative/spectator) vs BLOCKED (invul window)
         if (!result.landed()) {
@@ -146,6 +147,9 @@ protected boolean onStuck() {
     }
 
     /** Impact effect once a hit lands, after damage/knockback and before removal. {@code hitEntity} {@code null} = block hit. */
+    /** Runs before the damage roll, so it fires even when the hit then i-frame-deflects (vanilla arrow flame order). */
+    protected void beforeEntityDamage(@NotNull Entity target) {}
+
     protected void onImpact(@Nullable Entity hitEntity) {}
 
     private void fireImpact(@Nullable Entity hit) {

pvp/src/main/java/io/github/term4/polyp/mechanics/projectile/entities/ProjectileEntity.java

@@ -104,6 +104,7 @@ public abstract class ProjectileEntity extends Entity implements ExternallyTicka
     private ProjectileTypeConfig.WaterModel waterModel = ProjectileTypeConfig.WaterModel.LEGACY;
     private boolean legacyBlockRay = false;
     private boolean inWater;
+    protected final boolean inWater() { return inWater; }
     /** Added before drag (vanilla fireball {@code mot += dir; mot *= drag}); ZERO for ballistic projectiles. */
     protected Vec acceleration = Vec.ZERO;
     /** Knockback origin: vanilla uses the shooter, not the projectile. */