Sable: Destructive 2.2.0 — Destruction, Compatibility & Safety

Version 2.2.0 is a large stability, compatibility, balance and visual-effects update for Sable: Destructive. It completes the impact-system overhaul, makes explosions and collisions safer around Sable sub-levels, fixes snow-covered terrain, improves hard-material destruction, prevents several Sable lifecycle crashes and adds a supported API for other mod authors.

The result is a destruction system that is more physical and more spectacular under heavy impacts, while being substantially safer during ordinary gameplay, large explosions, level unloading and repeated collision events.

Major highlights

• Fixed explosions and mine-triggered explosions crashing while scanning Sable plots.
• Fixed explosions producing sound while destruction of affected Sable blocks was skipped after an unsafe plot access.
• Fixed thin snow remaining suspended after the dirt, grass or other supporting terrain below it was destroyed.
• Fixed collision dust being spawned in Sable's hidden plot-storage space instead of the visible parent world.
• Fixed removed sub-levels continuing heat-map splitting and attempting to assemble blocks inside an already removed plot.
• Rebalanced high-toughness finite blocks so the 20–30 toughness range is no longer effectively immortal.
• Preserved meaningful armour behaviour for obsidian, netherite and reinforced materials.
• Improved heavy-impact flash, shockwave, debris, dust-plume, sound and camera feedback.
• Added strict server and client budgets so large destruction events scale down safely instead of flooding the tick or render loop.
• Added the public SableDestructiveApi integration surface for weapons, vehicles, explosives and other addons.
• Removed normal-shutdown diagnostic spam and filtered harmless Modrinth App launcher disconnects.

Collision destruction and impact physics

• Rebuilt the break decision around a deterministic kinetic-energy and fracture-cost model.
• Impact calculations now account for:
  • defender block mass;
  • defender material strength and fracture toughness;
  • real Sable body mass;
  • attacker contact hardness;
  • relative impact speed;
  • reduced contact mass;
  • impact-energy retention;
  • the difference between known and unknown attacker materials.
• Fixed inconsistent Sable mass conversion and removed the former second application of massScale.
• Added a capped mass advantage. A huge construction still hits harder, but additional soft blocks cannot provide unlimited armour penetration.
• Added a physical low-speed safety floor. Small blocks dropped from ordinary heights bounce or stop instead of repeatedly drilling through terrain.
• Unknown contact materials are treated conservatively as ordinary material instead of inheriting the defender's hardness.
• Invalid or missing mass, speed and direction values are sanitized before entering the destruction queue.
• Soft attacking faces can damage themselves when they strike a significantly harder surface.
• Damage is block-by-block by default, avoiding the old long layer-shaped trenches.
• Optional penetration now spends actual remaining fracture energy one block at a time.
• Penetration is disabled by default, requires an extreme impact when enabled and is capped at two additional blocks.
• Optional cluster detachment is disabled by default and protected by parent, size, speed, cooldown and active-fragment limits.
• Detached fragments inherit safe motion, receive bounded separation and rebound impulses, and are explicitly woken in Sable's physics pipeline.
• Failed or unsafe detach operations fall back to a controlled VANISH result instead of leaving a half-assembled fragment.

Material balance

• Rebalanced the ordinary finite toughness table so blocks above the stone band can actually fail under proportionate impacts.
• Materials in the former 20–30 toughness dead zone are substantially less resistant than before.
• Mid-strength stone and masonry remain tougher than dirt, snow, leaves and glass.
• Hard materials still require both sufficient speed and sufficient fracture energy; mass alone is not an automatic bypass.
• Extremely fast impacts can gradually relax the contact-material ratio for a known attacker, so finite materials do not become absolutely immortal.
• Unknown attackers cannot use a fabricated huge mass value as a reliable shortcut through the strongest material tiers.
• Obsidian, crying obsidian, respawn anchors, ancient debris, netherite and reinforced deepslate retain dedicated high-tier material entries.
• Bedrock, barriers, command blocks, structure infrastructure, portals and other administrative or immutable blocks remain protected.
• Modded blocks without a dedicated entry receive a bounded fallback based on vanilla hardness, explosion resistance and map-colour density.
• The material cache can be invalidated cleanly when configuration or registry-dependent values change.

Snow and winter-biome behaviour

• Added dedicated fragile-snow classification for snow layers, snow blocks and powder snow.
• Added a snow-specific impact multiplier so light snow gives way before the terrain beneath it.
• Fixed moving Sable constructions passing through the visible snow cover while breaking only the dirt or grass block below.
• When a collision or shockwave removes a supporting terrain block, a thin minecraft:snow layer directly above it is now removed in the same tick.
• The support cleanup works in both the normal world and plot-local Sable destruction paths.
• Plot-local snow cleanup checks the exact plot bounds before accessing the embedded level, preserving compatibility with older Sable builds.
• Snow cleanup uses the same no-block-drop destruction policy and does not generate an extra vanilla explosion-particle event.
• Full snow blocks and powder snow are not blindly removed merely because a lower block changed; only unsupported thin cover receives the automatic cleanup.

Explosions and mine compatibility

• Hardened the NeoForge explosion path used by TNT, creepers, end crystals, beds, respawn anchors and compatible modded explosives or mines.
• Explosion spheres are now clamped to each Sable plot's real local bounding box before EmbeddedPlotLevelAccessor is queried.
• Empty space outside a plot is never scanned through unsafe negative or unmapped plot chunk indices.
• Removed, missing and partially unloaded sub-levels are skipped safely.
• One broken or stale plot can no longer abort processing for every other Sable construction in the same explosion.
• Per-sub-level and per-outcome exception containment prevents an individual bad target from crashing the complete explosion event.
• Break candidates are collected first and processed from the explosion centre outward.
• A strict maximum-break budget prevents very large explosions from producing an unbounded amount of synchronous plot work.
• Internal explosions use configurable absorption while external explosions use distance-based energy falloff.
• VANISH outcomes remove the block without creating the vanilla block-item drop or duplicate break event.
• Container blocks still spill their inventory contents before being removed.
• DETACH outcomes now queue a real Sable physics fragment with an outward explosion impulse.
• If a fragment cannot be created safely, the result falls back to VANISH rather than silently doing nothing.
• Explosion visuals are transformed from plot-local coordinates to the actual parent-world position.

Heavy impacts, flash and shockwave effects

• Heavy shockwaves now require a substantial falling body and confirmed contact with solid world terrain.
• Impact origin is resolved from the transformed lower centre of the Sable construction instead of an arbitrary storage coordinate.
• Crater radius, depth, debris, knockback and effect strength use bounded mass- and speed-based scaling.
• Craters are processed from the centre toward the rim, keeping their shape coherent if the server break budget is reached.
• Shockwave pressure uses a dedicated effective contact hardness rather than pretending the crater was made by a soft dirt projectile.
• Added a fast contact flash to make the first impact frame readable.
• Added separate dusty and translucent pressure fronts with different expansion speeds.
• Added physical-looking faceted rubble with gravity, world collision, bounce damping and delayed settling.
• Added a rising turbulent dust column and a delayed ground-hugging dust skirt.
• Added secondary debris and dust phases so giant impacts feel like one continuous event rather than a single flat particle burst.
• Added severity-scaled impact boom, low rumble and crater-crack sound layers.
• Added distance-attenuated camera-angle and FOV shake with a fast initial vibration followed by a slower rumble.
• Camera shake, cinematic effects, effect density, crater depth, radius and knockback remain configurable.
• A lightweight classic-effect fallback is used when the cinematic impact suite is disabled.

Dust, particles and coordinate-space fixes

• Collision dust originating from a Sable storage position is now transformed into parent-world coordinates before it is sent to clients.
• Collision dust no longer becomes attached to the moving sub-level that caused the collision.
• Fixed dust appearing in the hidden Sable plot world or colliding with invisible plot geometry.
• Explicit sub-level effects that should move with a live construction still use plot-local coordinates and Sable particle tracking.
• Plot effect payloads are normalized from storage coordinates to valid local coordinates before transmission.
• Invalid or out-of-bounds plot particle positions are rejected instead of reaching client particle physics.
• Improved sub-level particle collision against floors and thin walls using actual block collision shapes.
• Missing client plot chunks or a removed client sub-level no longer crash the render thread.
• Fixed dust and grit settling or bouncing in the wrong coordinate space.
• Fixed particle-atlas handling that could make flash, dust and shockwave sprites look square, clipped or incorrectly centred.
• Added dedicated shader passes for pressure waves, volumetric plume particles and faceted rubble.
• The complete effect suite now uses dedicated shatter, dust, shockwave, spark, flash, grit, pressure, plume and rubble rendering.

Performance and multiplayer

• Collision callbacks only enqueue validated lightweight contact records; destructive world changes remain on the server tick.
• The break queue is lock-free and uses an atomic size counter.
• Added an epoch-based contact deduplication ring to collapse repeated physics callbacks for the same collision.
• Added per-physics-step offer limits, total queue capacity and per-server-tick drain budgets.
• Queue entries belonging to an unloading level are removed without disturbing other dimensions.
• Pending detaches are also cleared when their level unloads or the server stops.
• Repeated nearby break effects use spatial and temporal deduplication to reduce particle and sound stacking.
• VANISH effects have a hard per-tick limit and degrade to reduced audio when the visual budget is exhausted.
• Heavy impacts send one compact deterministic event to each nearby player instead of hundreds of individual particle packets.
• Clients expand that event locally using a shared seed.
• Particle density scales with distance, the configured effect scale and Minecraft's All, Decreased or Minimal particle setting.
• Added a shared per-tick client spawn budget.
• Simultaneous long-lived heavy-impact sequences are capped.
• Players outside the effect range do not receive the impact payload.
• Dedicated servers do not load client-only particle, shader, camera or configuration-screen classes.

Crash and lifecycle safety

• Fixed Sub-level assembly attempted inside plot of already removed sub-level.
• Added a compatibility mixin that cancels Sable heat-map tick() and split() operations after their owner sub-level has been removed.
• Added repeated isRemoved() checks before plot access, cluster assembly, fragment registration and final impulse application.
• Added a short break-immunity window for newly detached fragments to prevent immediate recursive re-splitting.
• Despawn and level-unload cleanup clears tracked fragments, queues, effect state and shockwave state.
• Explosion and collision handlers contain failures locally and continue processing safe work.
• High error rates temporarily disable destructive processing for 60 seconds instead of allowing a runaway failure loop.
• Destruction automatically resumes after the emergency-disable window expires.
• Normal game shutdown no longer creates sable-destructive-shutdown-*.log.
• Genuine uncaught failures create at most one sable-destructive-emergency-*.log per process.
• Emergency reports retain the useful thread, uptime, queue, dedup, processed-event and error-rate counters.
• Harmless Modrinth App Theseus RPC SocketException / UncheckedIOException disconnects are recognized as external launcher shutdown noise and ignored.
• A failed report write can be retried by a later genuine emergency.

Block removal and inventory safety

• Centralized collision, shockwave, explosion and public-API block removal through ImpactBlockBreak.
• Blocks destroyed by Destructive do not drop a duplicate block item.
• Vanilla level event 2001 is avoided, preventing duplicate vanilla explode-block dust on top of the custom effect.
• Block entities are removed defensively.
• Randomizable containers unpack their loot table before destruction.
• Chests and other containers spill and clear their contents instead of deleting inventory data.
• World and plot-local removal share the same safety rules.
• Thin snow support cleanup is now part of this central path, so future integrations receive the fix automatically.

API and compatibility for other mod authors

• Added com.destroynautics.sabledestructive.api.SableDestructiveApi.
• Added stable API version constant API_VERSION = 2_2_0.
• Added isEnabled() for checking whether destructive processing is active.
• Added evaluateImpact(...) for obtaining the complete deterministic break verdict.
• Added canBreak(...) for simple material, mass and speed checks.
• Added destroyWorldBlock(...) for safe no-block-drop world destruction.
• Added destroySubLevelBlock(...) for safe plot-local destruction using Sable local coordinates.
• Other mods no longer need to access the internal break queue, explosion handler or plot-storage conversion details.
• The shared destruction API preserves container contents, protected blocks, snow-support cleanup and the common no-duplicate-particle policy.
• Public integration is intended for weapon, mine, bomb, vehicle and structural-damage addons.

Configuration and defaults

• Kept persistent configuration in config/sabledestructive-common.toml.
• The /sable-dv config panel exposes the important gameplay and visual controls.
• Layer penetration and multi-block detach ship disabled by default for stable block-by-block damage.
• Explosion handling, shockwave terrain damage, falling dust and heavy-impact effects can be controlled independently.
• Material ratio, self-damage, queue capacity, per-tick budgets, fragment limits and safety ceilings remain tunable.
• Added a safe world-space collision-dust default.
• Snow receives a dedicated default impact multiplier without weakening the supporting terrain.

Compatibility

• Minecraft 1.21.1
• NeoForge 21.1.243 or newer
• Sable 2.0.3 or newer
• Java 21
• Client, integrated server and dedicated server supported
• Mod version: 2.2.0
• Public API version: 2_2_0

Verification

• Clean Gradle build completed successfully.
• 7 deterministic impact-physics regression tests passed.
• 0 test failures.
• 0 test errors.
• Final artifact: sabledestructive-2.2.0.jar.
• SHA-256: 368C8DC576EF70A7803B4DF9DB46C6C4CA01F093AD04FA0243E714A10A717C43.

Upgrade notes

• Remove the previous Sable: Destructive JAR before installing 2.2.0.
• Install only one version of Sable: Destructive.
• Fully restart Minecraft or the dedicated server after replacing the file.
• Do not hot-swap the mod while a world or server is running.
• Existing configuration files remain supported; review the new defaults if upgrading from an older aggressive penetration setup.

---

Sable: Destructive 2.1.0 — Impact Overhaul

Version 2.1.0 rebuilds collision damage, heavy landings and destruction effects around a safer material-and-energy model. Small accidents remain small, while genuinely massive impacts can tear structures apart, fracture ordinary hard materials and leave a convincing crater.

Highlights

• Reworked damage into block-by-block structural failure instead of long layer-shaped trenches.
• Added cinematic giant-impact sequences with a contact flash, expanding shock fronts, ballistic rubble, an upward dust plume and delayed settling dust.
• Added three new custom shaders for pressure waves, volumetric dust plumes and faceted rubble. The mod now uses nine dedicated particle shaders.
• Added distance-attenuated camera and FOV shake with a fast impact kick followed by a slower ground rumble.
• Added circular, severity-scaled craters and stronger heavy-impact pressure damage to world terrain.
• Added client-side LOD and compact event networking to keep large effects practical in multiplayer.

Damage and material balance

• Replaced the previous mass heuristic with a deterministic kinetic-energy, reduced-mass and material-toughness model.
• Added a low-speed safety floor: dropping a normal stone block from roughly two blocks no longer makes it drill toward the bottom of the world.
• Disabled layer penetration by default. Optional extreme-impact penetration requires at least 20 m/s and is capped at two additional blocks.
• Disabled multi-block cluster detach by default so normal damage progresses one contact block at a time.
• Added a capped mass advantage. Adding more grass or another soft material no longer turns it into an armour-piercing projectile.
• Added attacker self-damage when a soft contact face hits a much harder defender.
• Rebalanced every finite ordinary toughness tier. Stone, metal, obsidian, netherite and reinforced blocks can fail under a proportionate impact instead of behaving as immortal blocks.
• Bedrock, barriers, command/structure blocks and portal infrastructure remain intentionally protected.
• Fixed Sable body-mass conversion and removed an accidental second application of massScale.
• Fixed explosion DETACH so it creates an actual physics fragment instead of silently deleting the block.

Giant-impact effects

• Heavy landings now require confirmed contact with solid world terrain.
• Impact origin is calculated from the transformed bottom centre of the falling Sable body.
• Added a fast dusty shock ring and a separate translucent pressure front.
• Added physical rubble with gravity, world collision and damped ground bounces.
• Added a long-lived rising plume with turbulent drift, expansion and gradual opacity loss.
• Added delayed skirt dust and secondary fragments after the initial collision.
• Added severity-scaled boom, low rumble and crater-crack sound layers.
• Fixed shader atlas handling that could make dust and shockwave sprites appear square, clipped or incorrectly centred.
• Dust and grit now collide and settle in the correct coordinate space, including particles attached to moving Sable sub-levels.

Performance and multiplayer

• A heavy impact now sends one compact deterministic event to each nearby player instead of hundreds of individual server particle packets.
• Particle density scales with distance and the player's Minecraft particle setting.
• Added a shared per-tick client spawn budget and a limit on simultaneous impact sequences.
• Existing server FX budgets, spatial deduplication and destruction queue limits remain active.
• Dedicated servers do not load client-only shader or screen classes.

Configuration

The /sable-dv config panel screen now includes controls for:

• Epic heavy-impact effects
• Camera shake enable/disable
• Camera shake strength
• Impact FX density
• Maximum shockwave radius up to 48 blocks
• Crater depth and knockback
• Material gates, self-damage and optional penetration

Settings remain persistent in config/sabledestructive-common.toml.

Compatibility and installation

• Minecraft 1.21.1
• NeoForge 21.1.235 or newer
• Sable 2.0.3 or newer
• Java 21
• Client and dedicated-server compatible

Remove the previous Sable: Destructive JAR, install sabledestructive-2.1.0.jar, and fully restart the game or server. Do not hot-swap this update.

Verification

• Clean Gradle build completed successfully.
• 7 deterministic physics regression tests passed.
• 0 test failures and 0 test errors.

fixed crash

Version 2.1.0 rebuilds collision damage, heavy landings and destruction effects around a safer material-and-energy model. Small accidents remain small, while genuinely massive impacts can tear structures apart, fracture ordinary hard materials and leave a convincing crater.

Highlights

• Reworked damage into block-by-block structural failure instead of long layer-shaped trenches.
• Added cinematic giant-impact sequences with a contact flash, expanding shock fronts, ballistic rubble, an upward dust plume and delayed settling dust.
• Added three new custom shaders for pressure waves, volumetric dust plumes and faceted rubble. The mod now uses nine dedicated particle shaders.
• Added distance-attenuated camera and FOV shake with a fast impact kick followed by a slower ground rumble.
• Added circular, severity-scaled craters and stronger heavy-impact pressure damage to world terrain.
• Added client-side LOD and compact event networking to keep large effects practical in multiplayer.

Damage and material balance

• Replaced the previous mass heuristic with a deterministic kinetic-energy, reduced-mass and material-toughness model.
• Added a low-speed safety floor: dropping a normal stone block from roughly two blocks no longer makes it drill toward the bottom of the world.
• Disabled layer penetration by default. Optional extreme-impact penetration requires at least 20 m/s and is capped at two additional blocks.
• Disabled multi-block cluster detach by default so normal damage progresses one contact block at a time.
• Added a capped mass advantage. Adding more grass or another soft material no longer turns it into an armour-piercing projectile.
• Added attacker self-damage when a soft contact face hits a much harder defender.
• Rebalanced every finite ordinary toughness tier. Stone, metal, obsidian, netherite and reinforced blocks can fail under a proportionate impact instead of behaving as immortal blocks.
• Bedrock, barriers, command/structure blocks and portal infrastructure remain intentionally protected.
• Fixed Sable body-mass conversion and removed an accidental second application of massScale.
• Fixed explosion DETACH so it creates an actual physics fragment instead of silently deleting the block.

Giant-impact effects

• Heavy landings now require confirmed contact with solid world terrain.
• Impact origin is calculated from the transformed bottom centre of the falling Sable body.
• Added a fast dusty shock ring and a separate translucent pressure front.
• Added physical rubble with gravity, world collision and damped ground bounces.
• Added a long-lived rising plume with turbulent drift, expansion and gradual opacity loss.
• Added delayed skirt dust and secondary fragments after the initial collision.
• Added severity-scaled boom, low rumble and crater-crack sound layers.
• Fixed shader atlas handling that could make dust and shockwave sprites appear square, clipped or incorrectly centred.
• Dust and grit now collide and settle in the correct coordinate space, including particles attached to moving Sable sub-levels.

Performance and multiplayer

• A heavy impact now sends one compact deterministic event to each nearby player instead of hundreds of individual server particle packets.
• Particle density scales with distance and the player's Minecraft particle setting.
• Added a shared per-tick client spawn budget and a limit on simultaneous impact sequences.

- Existing server FX budgets, spatial deduplication and destruction queue limits remain active.

- Dedicated servers do not load client-only shader or screen classes.

## Configuration

The /sable-dv config panel screen now includes controls for:

- Epic heavy-impact effects

- Camera shake enable/disable

- Camera shake strength

- Impact FX density

- Maximum shockwave radius up to 48 blocks

- Crater depth and knockback

- Material gates, self-damage and optional penetration

Settings remain persistent in config/sabledestructive-common.toml.

## Compatibility and installation

- Minecraft 1.21.1

- NeoForge 21.1.235 or newer

- Sable 2.0.3 or newer

- Java 21

- Client and dedicated-server compatible

Remove the previous Sable: Destructive JAR, install sabledestructive-2.1.0.jar, and fully restart the game or server. Do not hot-swap this update.

## Verification

• Clean Gradle build completed successfully.
• 7 deterministic physics regression tests passed.
• 0 test failures and 0 test errors.

Fixes

• Crash: Sub-level assembly attempted inside plot of already removed sub-level — despawn now clears the plot with destroyAllBlocks() then removes via the container; detach refuses break-immune / already-removed parents and vanishes leftover blocks instead of restoring into a dying plot
• Dust / grit: particles no longer appear as a speck in the sky or vanish instantly — plot-local coords are sent over the wire, the client embeds them into the live sub-level pose, and sim runs in local space with visible alpha
• Falling-dust rim sampling uses center-of-mass instead of the empty plot AABB

Changes

• Version bumped to 2.0.1
• Full Modrinth / README description restored and updated for 2.0.x (commands, Sable 2.0.3+ requirement)

Notes

• Replace the old jar completely and restart the game (hot-swap is not enough after the despawn path change)
• Requires Sable 2.0.3+ on NeoForge 21.1.235+ / Minecraft 1.21.1

Major release for Sable: Destructive — operator controls, denser boundary debris, and safer particle interaction with Sable sub-worlds.

Author / credits

• Mod & integration: DestrouNautics (Sable: Destructive addon)
• Physics engine API: Sable by ryanhcode (NeoForge 1.21.1, Sable 2.0.3)
• Built on NeoForge packet payloads, custom core shaders, and Sable HELPER projection/collision helpers

What's new

• /sable-dv on|off — toggle all destruction systems (operator)
• /sable-dv config reset — restore shipping 2.0.0 balance defaults
• /sable config panel (also /sable-dv config panel) — interactive brass “Flight Deck” operator panel (Create Aeronautics inspired): toggles, sliders, animations, UI sounds; APPLY syncs to the server
• New boundary grit particle + custom grit shader — dirt chunks fan outward from sub-level rims in mixed directions
• Dust/grit particles no longer tunnel through sub-worlds (client project-out + bounce against Sable volumes)
• Impact break still never drops block items; container contents (chests, etc.) still spill
• Version bumped to 2.0.0

Notes

• Panel edits require operator permission (permission level 2+)
• Dedicated-server safe: client panel/shaders load only on the client

Built against Sable 1.2.2 (the API surface we use is stable from 1.1.3 → 1.2.2 — no source changes required, this is a recompile + diagnostics release).

What's new

• Startup self-check. The very first INFO line in the log now reads [Sable: Destructive] addon=1.7.2 sable=1.2.2 (or sable=NOT LOADED with a loud warning if Sable is missing). Future API-mismatch reports become a two-line paste instead of a full log dump.

• /sable-dv diag — live counters for "is the shockwave alive?":

  • Server waves emitted + packets actually sent
  • BreakQueue throughput (offered / processed / pending / dropped by capacity vs. dedup)
  • SubLevelMassResolver cache hit/miss/fallback rates
  • Detected Sable runtime version

  The command also prints a hint based on what it sees:

  • Zero waves → magnitude / mass gate is filtering everything. Lower shockwaveMinMagnitude or shockwaveMinAttackerMassUnits.
  • Waves but zero packets → no players inside shockwaveClientHorizonBlocks. Stand closer or raise it.
  • Both non-zero → server is healthy; if the client sees nothing, install the addon CLIENT-side too.

• Compiled against Sable 1.2.2 (libs/sable-neoforge-1.21.1-1.2.2.jar). The 1.1.3-only compileOnly/localRuntime entries in build.gradle were swapped over so the IDE dev-runtime now matches the version most users have installed via Modrinth.

Crash report note (NOT Sable: Destructive)

• The Create / Registrate chocolate_bucket NPE crash users have been seeing is a known Create 6.0.10 bootstrap-ordering bug. Our mod is not in that stack trace — we don't subscribe to RegisterEvent or touch Create, Registrate, items, fluids, or advancements. Typical fix: remove duplicate Aeronautics jars (bundled + standalone), or redownload the Create jar if corrupt.

Requirements

• Minecraft 1.21.1, NeoForge 21.1.227+, Sable 1.1.3 or newer (tested on 1.2.2 — earlier 1.1.x still loads at runtime, only the registered Sable APIs we use need to exist).

MIT License

Hotfix for "модовые блоки не ломаются" — the callback was silently skipping every block with an attached BlockEntity, which is the overwhelming majority of modded machinery (Create cogwheels and shafts, Mekanism cables, Applied Energistics buses, every chest / furnace / hopper, etc.). That made the addon visually a no-op against most non-vanilla builds.

Why it was skipped originally

• Pre-1.6.1 the callback assumed BE teardown was always fragile — Sable's sub-level assembler doesn't preserve BE NBT cleanly, and peeling a half-built contraption can corrupt its kinetic-network state on the modded side.

What changed

• allowBlockEntityBreaks (new, default true). BE-bearing blocks ARE now broken on contact. The block is removed via an explicit level.removeBlockEntity(pos) BEFORE the setBlock(AIR), so the BE's saved NBT is discarded cleanly and no vanilla on-remove side-effect can throw out of the callback.

• allowBlockEntityDetach (new, default false). Even when BE breaks are allowed, the outcome is forced to VANISH — never DETACH. Reason: Sable's assembler doesn't carry BE NBT into the new sub-level, so peeling a Create gearbox would instantly desync its kinetic network. VANISH discards the BE cleanly. Set to true if you want the experimental "peel BEs too" behaviour (expect cosmetic issues on Create/Mekanism).

• safeSetAir now explicitly removes any attached BlockEntity before airing the cell. Catches any throwable from the BE's own remove handler (Create kinetic teardown, Mekanism cable rebuild, etc.) so a third-party mod's on-remove bug can never escape into Sable's native bridge.

Compatibility

• Set allowBlockEntityBreaks=false in config/sabledestructive-common.toml to restore the pre-1.6.1 "skip every BE block" behaviour.
• All other 1.6.0 knobs and behaviour unchanged.

Requirements

• Minecraft 1.21.1, NeoForge 21.1.227+, Sable 1.1.3+

MIT License

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