advanced_storm_controller_device

storm_manager := class(creative_device):

    # We define our main storm controller.
    # Think of this as the "boss" device.
    # Note: tag this property @editable so you can assign it in the UEFN editor.
    @editable
    my_controller : advanced_storm_controller_device = advanced_storm_controller_device{}

    # We define a beacon to change the storm's look.
    # This is like a remote control for the storm.
    # Note: tag this property @editable so you can assign it in the UEFN editor.
    @editable
    my_beacon : advanced_storm_beacon_device = advanced_storm_beacon_device{}

    # This function runs when the game starts.
    OnBegin<override>()<suspends>:void=
        # First, the beacon is configured in the UEFN editor to link to a storm phase.
        # advanced_storm_beacon_device does not expose an Enable call in Verse;
        # enable/disable the beacon via its editor properties instead.
        # This is like flipping a switch to "Advanced Mode".

        # Next, we generate the storm so the controller begins running phases.
        # Imagine telling a robot: "Start your task list now."
        # Note: phase-to-beacon links are set up in the UEFN editor via
        # the controller's Storm Phases settings; Verse activates the devices.
        my_controller.GenerateStorm()

        # Finally, we destroy and regenerate as needed — the storm will now
        # shrink in stages as configured in the editor.
        # The storm is now active and will respond to its phase configuration.

CustomStormGameMode := class(creative_device):
    # These are the device references we place in the level and connect via the editor.
    # We reference them directly as editable properties instead of using Find_Device.
    @editable
    storm_controller: advanced_storm_controller_device = advanced_storm_controller_device{}

    @editable
    beacon_chill: advanced_storm_beacon_device = advanced_storm_beacon_device{}

    @editable
    beacon_killbox: advanced_storm_beacon_device = advanced_storm_beacon_device{}

    # This function runs once when the game starts.
    # It's like the "Start Game" button on the menu.
    OnBegin<override>()<suspends>: void =
        # 1. Find our devices. 
        # We need to find the Controller and the Beacons in the world.
        # In Verse, we usually find devices by name or reference.
        # For this simple example, we assume they are placed in the level 
        # and we can reference them.
        
        # The Advanced Storm Controller and Beacons are connected via
        # @editable properties above — no Find_Device needed in UEFN.
        
        # 2. Set the Controller to Custom Mode.
        # This is like flipping the switch on the Battle Bus to "Custom."
        # Storm phase and beacon assignments are configured in the UEFN editor
        # on the advanced_storm_controller_device and advanced_storm_beacon_device
        # properties — there is no Verse API call needed here.
        
        # 3. Assign the Beacons to the Phases.
        # Beacon-to-phase assignment is handled in the UEFN editor via the
        # advanced_storm_beacon_device settings (set the Phase number on each beacon).
        # beacon_chill  -> Phase 1  (set in editor)
        # beacon_killbox -> Phase 2 (set in editor)
        
        # 4. Start the Storm!
        # The storm doesn't start automatically when "Generate Storm On Game Start"
        # is set to No. We call GenerateStorm() to trigger it from Verse.
        storm_controller.GenerateStorm()