The whole break/shockwave pipeline now reads each Sable sub-level's ACTUAL mass (in kg) from Sable's own MassData tracker instead of treating every attacker as a hard-coded 2000 kg "default ship". Per the Sable wiki, every block carries a sable:mass property (kpg); ServerSubLevel#getMassTracker().getMass() returns the sum that the physics pipeline itself uses for Rapier. We just read it.

This single change fixes the long-standing complaint that "a tiny flying chunk feels exactly as heavy as a 5000-block ship": below, the same 12 m/s impact now produces three very different outcomes depending on the attacker's real mass.

What is new

• SubLevelMassResolver — single source of truth for per-sub-level mass. O(1) per call (queries ServerSubLevel#getMassTracker()), per-tick identity-keyed cache, defensive fallback to defaultAttackerMassKg on any Sable-side failure. Hard-capped at subLevelMassHardCapKg = 1e8 kg to prevent a corrupted physics tick from making the energy budget infinite.

• Mass-aware kinetic-energy budget. BreakResolver.shouldBreakState was already a kinetic-energy formula, but it was always fed 2000 kg. Now it sees the real attacker mass, so:

  • A 100 kg flying cobblestone at 12 m/s = 7 200 J → bounces off stone (budget 18 kJ).
  • A 50 t small ship at 12 m/s = 3.6 MJ → punches stone wide open.
  • A 500 t fortress at 6 m/s = 9 MJ → grinds through obsidian. The reduced-mass term µ = m1·m2/(m1+m2) means a feather-light attacker still cannot pulverize a heavy defender — the math collapses to the attacker's own KE budget.

• Mass-aware structural-toughness gate. The "soft attacker can't pierce hard defender" rule (attackerToughnessRatio) now has a mass relief factor: the required attacker toughness is scaled by sqrt(massToughnessReferenceKg / realMass), floored at massToughnessReliefFloor. A 100 t crusher made of packed dirt WILL pulverize stone purely from inertia; a thrown dirt clump won't. Defaults: massToughnessReferenceKg = 4000, massToughnessReliefFloor = 0.1 (so at most a 10× relief — a fully soft Jell-O sub-level can never bypass the gate entirely).

• Shockwave magnitude now uses the same real mass. The bespoke flood-fill (computeAttackerMassUnits, O(N) up to 1500 blocks per emit) is no longer the primary path — when useSubLevelMass=true we feed Sable's mass tracker × shockwaveAvgToughnessUnits (= 120, i.e. V_STONE × 10) so all existing magnitude thresholds keep their meaning. Flood-fill remains as the fallback for the unlikely case where the mass tracker has not been built yet. Net result: shockwave emission is now O(1) per impact and reflects the real ship size, not a 6-neighbour sample of it.

• New persistent config knobs (TOML hot-reload as usual):

  • useSubLevelMass (bool, default true)
  • subLevelMassHardCapKg (kg, default 1e8)
  • massToughnessReferenceKg (kg, default 4000)
  • massToughnessReliefFloor (×, default 0.1)
  • shockwaveAvgToughnessUnits (units, default 120)

What is fixed

• "Two tiny dirt blocks shouldn't break obsidian by being heavy" — was actually still happening for SHIP-vs-OBSIDIAN because the callback was hard-coding 2000 kg. With real mass, a 200 kg dirt fragment now correctly fails the gate AND fails the energy budget.

• Heavy ships landing softly used to bounce indefinitely because every contact was rated at 2000 kg @ low speed = 144 kJ, below every threshold. They now report their real mass, so a 100 t ship setting down at 4 m/s = 800 kJ punches through dirt/wood as expected.

• Shockwave was firing inconsistently for big builds because the flood-fill capped at shockwaveMassFloodCap = 1500 blocks underestimated ships larger than that. The real mass tracker has no such cap.

Backward compatibility

• useSubLevelMass=false restores the pre-1.6.0 behaviour exactly (hardcoded defaultAttackerMassKg, flood-fill for shockwave).
• All existing config keys preserved with the same defaults.
• BreakResolver.shouldBreakState(...) signature unchanged.
• ShockwaveEffect.emit(level, center, energy) overload kept; a new emit(level, center, energy, attackerMassKgHint) overload is preferred by callers that already have the resolved mass.

Requirements

• Minecraft 1.21.1
• NeoForge 21.1.227+
• Sable 1.1.3+ (uses ServerSubLevel#getMassTracker())

Credits

• Code: Xylos_Official
• Visuals: Viaquelt
• Built on top of Sable by ryanhcode

MIT License