Summary of "In Game Level Editor - Custom Property System (Unreal Engine)"

High-level summary

This tutorial demonstrates how to use the in-game level editor plugin’s custom property system (Unreal Engine) to store per-placeable data and expose custom UI to edit those values.
Two example uses are shown:
1. An advanced reference property used by a button to point to a door (the reference is saved with the level and drives behavior at runtime).
2. A step-by-step build of a simple Boolean custom property that hides/unhides a placeable cube and persists across save/load and play.
All example work is done in Blueprints and uses an example project included with the plugin.

Key concepts and lessons

Purpose: attach custom, persisted data to placeable actors and optionally provide a custom widget for editing that data in the editor UI.
Property definition:
- A name.
- An optional category/options string.
- A property class that contains the actual data and the widget class for editing it.
Persistence and runtime:
- Property instances are saved with the level and are available when the level is loaded or during play, so properties can drive runtime behavior.
Property types:
- Hidden properties (no UI) for internal data.
- Advanced properties that store references to other placeables (filterable via options) and provide richer UIs.
Events/callbacks:
- The plugin exposes an event/callback so a placeable can respond when a property value changes (on edit and on load).

Detailed step-by-step implementation (create a Boolean `is_hidden` property for a cube)

Prepare the placeable
- Open the example level and select the placeable (the presenter renamed a copy of an existing Cube to “HiddenCube”).
- Locate the component that holds placeable properties (the properties array on the placeable’s interface/component).
Add a property entry to the placeable
- Add an element to the properties array.
- Set the property entry fields:
  - Name: e.g., is_hidden
  - Category: optional
  - Options: optional string for custom filtering/options
  - Class: set to your custom property class (created in the next steps)
Create the custom property class
- Create an object/class that derives from the plugin’s Property Value Object base class.
- Add a variable to this class to hold the data (in this example add a Boolean variable named Value).
- Set the property class’s ValueWidgetClass to the custom widget you will create (so the editor knows which widget to draw for editing this property).
Create the custom value widget
- Make a User Widget that inherits from the plugin’s Property Value Widget base (this base gives you a reference to the property object).
- Add a Checkbox widget to the User Widget layout.
- In the widget graph:
  - Use the provided property reference (a pointer to the property object instance).
  - Cast the property object to your custom property class type.
  - On widget initialization/construct: read the property’s boolean value and set the Checkbox IsChecked so the UI reflects current data.
  - Bind to the Checkbox’s OnCheckStateChanged event:
    - Cast the property object to your custom type and set its Value to the new checked state.
    - Call the plugin’s notification node (e.g., TryCallPropertyValueChanged / property value changed caller) to notify the placeable that the property changed.
Hook up the property to the placeable
- In the HiddenCube’s properties array entry, set Class to the custom property class and set Name to is_hidden.
- Ensure the property’s ValueWidgetClass is set so the checkbox appears in the editor.
Respond to property changes in the placeable
- In the placeable (HiddenCube) implement the OnPropertyValueChanged handler (this event is invoked on property change and also when the level loads).
- In that handler:
  - Check if the changed property name equals is_hidden.
  - If so, get the property by name, cast to your custom property class, read the Boolean Value, and call SetHiddenInGame (or otherwise set visibility) using that Boolean.
- Because the property change event also fires on level load, you don’t need a separate BeginPlay setup to apply the stored state.
Test and save
- Use the editor UI to toggle the is_hidden checkbox for the placeable.
- Save the level, reload the editor (or play), and confirm the property persisted and the cube is hidden/unhidden as expected.

Note: Hiding does not necessarily remove collision — the cube may still block movement unless you change collision settings.

Practical notes, tips, and capabilities

Options string: the property entry includes an options field that you can use to pass arbitrary filtering or configuration to the property/widget (for example, limit choices to placeables of a certain class).
Reference properties: you can store references to other placeables (example: a button target door reference that filters by door class). These references persist with the level and allow runtime wiring between placeables.
Hidden/data-only properties: useful for storing internal values like shared colors without exposing UI.
Blueprint examples: everything in the example is Blueprint-based; inspect the example project Blueprints to learn details and exact node names.
Change notifications: use the plugin-provided callback node to notify the placeable that a property value changed so you can drive actor behavior immediately and on load.

What was demonstrated

Wiring up an is_hidden Boolean property and custom widget so the cube is hidden in-editor and in-game when the property is true, with the state persisting across save/load and play.
An earlier example showed a button referencing a door and both sharing a hidden color property.

Speakers / sources featured

Tutorial presenter / video narrator (unnamed).
Example project and Blueprints included with the in-game level editor plugin (referenced on the plugin docs/store page).