# Keep broken destructibles broken

> Bridges, walls and crates built as Chaos geometry collections come back broken after a load, travel and streaming: each piece that broke off where it lay,...

Product: Rolly Save 1.0.0 | Sheet: guide | Updated: 2026-10-31 | HTML: https://rolly-docs.pages.dev/save/guides/destruction/

## Choose what a broken collection keeps

**Destruction** sits beside the actor's other saving settings: Project Settings > Plugins > Rolly Save > Actor Defaults, a Save Rule, or the actor's Rolly Save component (see [Choose what saves](https://rolly-docs.pages.dev/save/guides/choose-what-saves/)). It takes every geometry collection component of the actor.

| Destruction | A load keeps |
|---|---|
| Off | Nothing: the collection is as the level designs it, and a load in place leaves it as it is |
| Broken Pieces | Each piece that broke off at its saved place; pieces that broke off together come back as separate resting pieces |
| Exact Groups (the default) | As Broken Pieces, and pieces that broke off together come back joined again |

Only a collection whose root broke saves: a whole collection costs nothing, and an actor with nothing else to save saves no record. Per piece the save holds whether it broke off, sits in a group or was removed, its physics state, and the place of each piece that broke. Removed pieces stay removed and fire no removal event again, also the members of a group that **Remove On Break** without **Cluster Crumbling** removed. Anchors come back as the asset sets them, also where your game changed them during play.

The section is the same under both values; Destruction at the load picks how it is restored, so switching it later loads old saves either way. Under Broken Pieces, the pieces of a former group settle on each other after the load, so the next save holds them as they then lie.

A load restores a collection once its component registered: in the map's own pass for a map that opens, after its level became visible for a streamed level, a level shown again or a cell loaded again, after the spawn for an actor the load spawns again, on the replacing component after Play In Editor's construction pass, and as your game registers a component it left unregistered. A level shown again as the same objects keeps its broken collections, with Remember Streamed Levels on or off: a sublevel made invisible, a World Partition cell deactivated but kept loaded, or a level or cell that unloads and is asked for again before garbage collection takes it. A level loaded again as new objects builds them anew, as the save or Remember Streamed Levels holds them. A collection your game makes whole after a load, as with **Reset State** or anything else that makes its physics state again, saves nothing from then on, until it breaks again. A load in place first makes each broken collection of its scope whole, then restores those the save holds broken; a collection the save holds whole stays whole. A part load sets only the collections of its part. A Reset Area that resets an actor makes its collections whole at the level's next build.

## React when pieces are restored

On the server or in a standalone game a restore fires no break, crumbling or removal event: game logic that runs on those events would otherwise drop loot or play sounds a second time. Clients are another matter: see [Show restored pieces on clients](#show-restored-pieces-on-clients). Rebuild what depends on the broken state in **On Rolly Save Loaded** of the actor, or the Rolly Save component's **On Loaded**. The physics shows the restored pieces from its next step, so keep the gameplay state yourself in a variable that saves, such as a bridge's **Collapsed**, and read that rather than the pieces.

### Blueprint

Add a Boolean variable **Collapsed** with **SaveGame** ticked under its advanced details. Tick **Notify Breaks** on the geometry collection component, which sends **On Chaos Break Event** only then, and set Collapsed in that event where your bridge falls. In **On Rolly Save Loaded** (implement the **Rolly Save Interface** in Class Settings), branch on Collapsed and close the road behind it.

### C++

```cpp
// Bridge.h
UPROPERTY(SaveGame)
bool bCollapsed = false;

UFUNCTION()
void OnRollySaveLoaded();

// Bridge.cpp
void ABridge::OnRollySaveLoaded()
{
	// The pieces are restored without break events: rebuild what the collapse changed.
	SetRoadClosed(bCollapsed);
}
```

## Show restored pieces on clients

Only the server or a standalone game saves and restores. With **Enable Replication** ticked under the geometry collection component's **Network** category, the server's restore reaches each client as the engine's own breaks do; without it a client shows the collection whole after a load. Untick **Enable Abandon After Level** there too: with it on, as the engine sets it, the server disables every broken piece of a level past **Replication Abandon After Level** and leaves it to each client, so neither the server nor a save knows those pieces; a listen or dedicated server that saves or restores such a collection says so in the Message Log (AbandonAfterLevel), and the editor's checks name each such collection of an actor whose Destruction is not Off when you save or check a map (Replicated Collections That Abandon Pieces, see [Check your save setup](https://rolly-docs.pages.dev/save/guides/check-save-setup/#keep-replicated-collections-from-abandoning-pieces)).

A client releases the restored pieces as the engine replicates any break, with break events: on a client with **Notify Breaks** ticked, **On Chaos Break Event** fires for the restored pieces after each load. Rolly Save runs no code on clients, and the engine's replication gives no way to stop those events, so keep effects that must not play twice off the break event on clients, or check the replicated state your game saves, such as a bridge's **Collapsed** marked **Replicated**, before you play them.

A client cannot join pieces again that broke on it, so a load in place onto a collection broken further since the save leaves those pieces apart on clients until the collection is made again, as when its level loads again. A collection the load spawns again, or one in a map the load opens, shows the restored state on every client.

## Hide destroyed actors in distant HLODs

**Hide Destroyed in HLOD** (Project Settings > Plugins > Rolly Save > Levels, on by default) destroys, in World Partition's destructible HLODs, each placed actor the save holds as destroyed or this session destroyed with Keep Destroyed on, so a wall players knocked down is not standing in the distance. It runs as each HLOD registers and after each load, on the server or in a standalone game; clients receive the state with the HLOD.

For an HLOD to take part, build its layer as destructible: set the HLOD layer's **HLOD Modifier Class** to **World Partition HLOD Modifier Mesh Destruction**, and give the actors players destroy a C++ class that implements Epic's **Destructible in HLOD Interface**, which a Blueprint cannot add. The HLOD lists them by name at its build, so an actor renamed since then matches nothing until the HLOD is built again.

Not hidden: actors saved under a Custom Save ID, whose ID holds no name; actors inside level instances; actors of FastGeo HLODs, which Epic's destruction does not cover. An actor a load or a Reset Area brings back stays hidden in an HLOD that stays loaded, since nothing in the engine raises it again, and shows once that HLOD registers again.

## Change a collection after release

A save names its collection by the asset's path, its piece count and a hash of its pieces' hierarchy and rest places. When one of them differs at the load, as after a new fracture, the pieces are kept and not set: the collection stands whole, the Message Log says so once per component and load (CollectionChanged), the load's Issues list GeometryCollectionChanged, and saves write the kept pieces back until the collection breaks again. Edits that change no piece, such as damage thresholds, materials or removal settings, keep old saves loading.

A fracture that keeps the piece count, the hierarchy and every rest place goes unnoticed, and the saved places then land on other shapes.

## What is not restored

- Strain on clusters that did not break, and the exact motion of pieces still moving at the save: they come back at rest where they were.
- A piece shrinking away at the save comes back at full size and starts its removal again.
- Anything of a collection that never broke, such as anchors or physics states your game changed.
- With Exact Groups, the groups Chaos forms from the released pieces: connection settings changed since the save can form others.
- A collection whose component does not simulate physics, has no physics state, or holds another number of pieces than the save, as after its asset changed during play: the restore fails, the collection stands whole, and the Message Log names why (RestoreFailed).
- A collection of more than 65,536 pieces, or a broken one without a physics state: its pieces are not saved, and the Message Log says so (PiecesNotSaved). A broken piece the physics flung to no finite place is saved in its cluster (PieceNotFinite).
- The pieces of the collections past a file's bound of 4,194,304 pieces: a save leaves them out and holds the rest, and the Message Log and the save's Issues name them (PiecesLeftOut, GeometryPiecesLeftOut).

## See restored pieces while you test

**Effective Settings** on the actor shows the Destruction value and where it comes from, subdued and "not used" on an actor without a geometry collection component. The Rolly Save column reads Destruction for an actor that saves only through Actor Defaults' Destruction, its tooltip "Actor Defaults: saves broken pieces". While playing, the Gameplay Debugger's RollySave category names each collection's pieces broken off, in groups and removed, and whether the last load restored them (see [See what an actor saves while you play](https://rolly-docs.pages.dev/save/guides/debug-while-playing/)). The console command `rolly.save.dump <slot> -records` lists each record's sections: a broken collection's component record holds a GCOL section of 16 bytes, 2 per piece and 40 per piece that broke.

In the Save Inspector (see [Inspect, compare and edit saves](https://rolly-docs.pages.dev/save/guides/inspect-saves/)), that record's **Destruction** group sums up the collection, such as "2 broken off, 1 in groups, 1 removed of 4 pieces". It holds the **Collection**, its path in the tooltip; whether its **Root** is Broken or Whole; the pieces **Broken Off**, **In Groups** and **Removed**, each as "Piece 3" at its place with its physics state (Sleeping, Kinematic, Static, Dynamic or User Defined), in pages of 1,000 when there are more; and how many pieces are **Anchored**. The rows are read only: break the collection in your game and save again, or drop its pieces with **Remove Record**. Pieces a later version wrote show under Other Sections, marked "Flags 0x00000002: kept for the version that wrote them".

![The Save Inspector's Destruction group](https://rolly-docs.pages.dev/save/_files/Images/Inspector_Destruction.png "GC_Bridge_1's record: its collection, the root Broken, and Broken Off, In Groups and Removed open with each piece's place and physics state.")