A bug where the active state of the game object controlled by the Activation Track is reset and returned to its original state after the Timeline has finished playing.

1.

You are the director (developer) of the play. In the middle of the play, I instructed Kuroi (Activation Track), ``At the middle of the play, please move (deactivate) the obstructive rock (game object) in the center of the stage to the side of the stage so that it is no longer visible.'' As instructed, Kuroi successfully cleared the rocks during the play, and the play reached a wonderful climax.

However, the moment the curtain falls to signal the end of the play (the end of the Timeline), the meddlesome Kuroi hurriedly replaces the rock in the center of the stage with a thud, saying, ``Now that the play is over, we need to return all the tools to their original state before the performance started!'' From the perspective of the audience (player), as soon as the curtain goes up, the rock that was supposed to have disappeared appears in the same place as if nothing had happened, and they feel a strong sense of discomfort, as if the magic has been broken.

This is the true meaning of "None (reset) behavior" in Timeline. It is necessary to clearly set rules for Kuroi, such as, ``Even after this play is over, leave the rocks you have put away where they are (Hold)'' and ``Do not put them back where they were without permission.''

2. Root cause: Initial specification of Wrap Mode and Out of Bounds

Technically speaking, the PlayableDirector that manages the Timeline has a property called Wrap Mode that determines the behavior of the entire timeline in loops and at the end. The default setting is None.

When Wrap Mode = None, when the current playback position of the Timeline reaches the end frame (Out of Bounds), control of the entire Timeline ends and the parameters of the target object (Transform, Active state, etc.) are forcibly restored (reset) to the state they were in before the Timeline started playing. This prevents temporary changes caused by Timeline playback from remaining in the scene.

However, if you want to perform a permanent state transition such as ``I want to permanently erase a wall after destroying it,'' this restoration behavior becomes a nuisance and manifests as a bug in which ``the erased object reappears.''

3. Three solution approaches that should be adopted in practice

Use the optimal approach depending on the situation and game system design.

Solution approach A: Set PlayableDirector's Wrap Mode to "Hold" (easiest)

This is the easiest method. The last state at the end of the Timeline will be maintained as it is.

1. Select the PlayableDirector component in your scene.
2. Change Wrap Mode from None (default) to `Hold` in the Inspector.

*This way, when the timeline ends, it will be paused at the state of the last frame (if the object is hidden, it will remain hidden) without being reset to the initial state.

Solution approach B: Forcibly lock the state from a C# script (recommended)

If you do not want to use Wrap Mode = Hold for reasons such as "I want to continue playing other timelines with the same object" or "I want to release memory when playback ends," the most robust method is to detect the Timeline end event and explicitly override the object state from C# code.

using UnityEngine;
using UnityEngine.Playables;

[RequireComponent(typeof(PlayableDirector))]
public class TimelineStateClamper : MonoBehaviour
{
    public GameObject targetObject;       // Object you want to keep in the deleted state
 public bool targetFinalActiveState = false; // Active state at the end (false if you want to delete it)
 private PlayableDirector director;

 void Start()
 {
 director = GetComponent();
 
 // Register a function for the Timeline playback completion (stop) event
 if (director != null)
 {
 director.stopped += OnTimelineStopped;
 }
 }

 void OnTimelineStopped(PlayableDirector pd)
 {
 if (targetObject != null)
 {
 // Immediately after Timeline runs the reset process, decide to overwrite the active state from the C# side
 targetObject.SetActive(targetFinalActiveState);
 Debug.Log($"Object active state forced to {targetFinalActiveState} on Timeline stop.");
 }
 }

 void OnDestroy()
 {
 if (director != null)
 {
 director.stopped -= OnTimelineStopped;
 }
 }
}

Solution Approach C: Use Signal Receiver to manage as game state

In larger games, you should avoid directly managing the presence/absence of physical walls using ``Show/Hide (Activation)'' in Timeline, and instead set a ``destruction flag'' on the game logic side at a specific timing (Signal) in Timeline. By calling the C# manager class using Signal, executing Destroy(wallObject) on the manager side, or writing to the save data, changes in the state of the object will be made permanent regardless of the playback state of the Timeline.

4. Practical Active Control Troubleshooting Checklist

If you are having trouble maintaining the status, check the following items.

• Active state of parent object: The controlled object itself is Active, but its parent GameObject is deactivated, so the child object is not displayed as expected, or vice versa.
• Multiple Track Conflicts: Is the same object being controlled by different Activation Tracks or Animation Tracks (m_IsActive property) at the same time? If there is a conflict, it will be overwritten with the value from the last evaluated track.