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.