internal static void Repeat(OperationTreeDescription treeDescription, int?repeatCount = null)
{
var isCounted = repeatCount.HasValue;
var count = 0;
var controlOp = new Operation(endAction: () =>
{
if (isCounted)
{
count++;
}
if (isCounted && count >= repeatCount)
{
return;
}
var isCancelled = treeDescription.IsCancelled();
if (isCancelled)
{
ManagedLog.Log($"Not restarting {nameof(OperationTreeDescription)}, root: {treeDescription.Root.Name}", ManagedLog.Type.Verbose);
}
else
{
ManagedLog.Log($"Restarting {nameof(OperationTreeDescription)}, root: {treeDescription.Root.Name}", ManagedLog.Type.Verbose);
treeDescription.Start();
}
});
treeDescription.AddOperation(controlOp);
if (!treeDescription.IsWaitingOrRunning())
{
treeDescription.Start();
}
}
private void OnValidate()
{
var col = GetComponent <Collider>();
if (!col)
{
ManagedLog.LogError($"{Internal_GameObject.name} doesn't have any Collider component!", gameObject);
}
if (col && !col.isTrigger
#region Editor
&& UnityEditor.EditorUtility.DisplayDialog("TriggerEvent", "TriggerEvent collider is not set as trigger, set it now?", "OK", "Cancel")
#endregion
)
{
col.isTrigger = true;
}
if (!_PhysicsObject)
{
_PhysicsObject = GetComponent <PhysicsObject>();
}
if (!_PhysicsObject)
{
_PhysicsObject = Internal_GameObject.AddComponent <PhysicsObject>();
}
}
public UniformScale(
Transform transform,
float duration,
float targetScale,
float delay = 0f,
EaseCurve?ease = null,
string name = null,
OperationSkipCondition skipCondition = null)
{
_targetScale = targetScale;
_transform = transform;
_duration = duration;
Delay = delay;
_skipCondition = skipCondition;
_ease = ease;
_updateAction = UpdateAction;
Name = name ?? $"{(_transform ? _transform.name + " " : "")} {nameof(UniformScale)}";
BindTo(transform);
#if UNITY_EDITOR // Check if initial scale is uniform.
if (Math.Abs(_transform.localScale.x - _transform.localScale.y) > Mathf.Epsilon ||
Math.Abs(_transform.localScale.x - _transform.localScale.z) > Mathf.Epsilon)
{
ManagedLog.LogError($"{transform.name} is scale is not uniform.");
}
#endif
}
public void SetIsVisible(bool isVisible)
{
Internal_GameObject.SetActive(isVisible);
#if UNITY_EDITOR
if (!Internal_GameObject.activeInHierarchy)
{
var firstDisabledParent = FindDisabledParent(Internal_Transform);
ManagedLog.LogError($"{gameObject.GetScenePath()} will not be visible because one of it's parents ({firstDisabledParent.gameObject.GetScenePath()} is disabled. ");
}
Transform FindDisabledParent(Transform t)
{
while (true)
{
if (!t.parent.gameObject.activeSelf)
{
return(t.parent);
}
if (t.parent == null)
{
return(null);
}
t = t.parent;
}
}
#endif
}
private static void AddAllComponentsInScene <T>(Scene arg0) where T : Component
{
var addedCount = 0;
var allObjectsInScene = arg0.GetRootGameObjects();
foreach (var gameObject in allObjectsInScene)
{
var components = gameObject.GetComponentsInChildren <T>();
addedCount += components.Length;
switch (components)
{
case View[] views:
Views.AddRange(views);
foreach (var view in views)
{
view.Internal_OnLoad();
}
break;
case ControllerBase[] controllers:
Controllers.AddRange(controllers);
break;
}
}
if (addedCount > 0)
{
ManagedLog.Log($"Added {addedCount} {typeof(T).Name} from {arg0.name} scene.", ManagedLog.Type.Structure);
}
}
private static void LogEvent(object msg)
{
if (!_logEvents)
{
return;
}
ManagedLog.Log(msg, ManagedLog.Type.Structure);
}
private static void LogUpdate(object msg)
{
if (!_logDrawUpdates)
{
return;
}
ManagedLog.Log(msg);
}
private static void OnEditorApplicationOnPlayModeStateChanged(PlayModeStateChange change)
{
if (change != PlayModeStateChange.ExitingPlayMode)
{
return;
}
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
StateMachines.Clear();
}
private static void InitializeOnLoadMethod()
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
PlayerLoopUtilities.AppendToPlayerLoop <Update.ScriptRunBehaviourUpdate>(typeof(BasicStateMachineEngine), Update);
#if UNITY_EDITOR
EditorApplication.playModeStateChanged += OnEditorApplicationOnPlayModeStateChanged;
#endif
}
public static void Stop(Coroutine coroutine)
{
if (coroutine == null)
{
ManagedLog.LogError($"Tried to stop a null coroutine.");
return;
}
Runner.StopCoroutine(coroutine);
}
private void OnValidate()
{
if (!_rigidbody)
{
_rigidbody = GetComponent <Rigidbody>();
}
if (!_rigidbody)
{
_rigidbody = gameObject.AddComponent <Rigidbody>();
_rigidbody.isKinematic = true;
ManagedLog.Log($"Added Rigidbody to {name}.", ManagedLog.Type.Info);
}
}
private static void InitializeOnLoadMethod()
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
SceneManager.sceneLoaded += SceneManagerOnSceneLoaded;
SceneManager.sceneUnloaded += SceneManagerOnSceneUnloaded;
PlayerLoopUtilities.AppendToPlayerLoop <Update.ScriptRunBehaviourUpdate>(typeof(ManagedLog), OnUpdate);
// SceneManagerOnSceneLoaded doesn't get called for initial scene in builds, we need to call it on load to capture Managed Objects
#if !UNITY_EDITOR
var activeScene = SceneManager.GetActiveScene();
AddAllManagedObjectsInScene(activeScene);
#endif
}
private static void CheckLevelEnterPlayModeForLoadingMainScene()
{
if (!ProjectEditorConfig.Instance.AutoTestLevelScenes)
{
return;
}
// No game exists
var game = FindAllObjects.InScene <GameBase>().FirstOrDefault();
if (game)
{
return;
}
// Found level helper
var sceneRef = FindAllObjects.InScene <LevelSceneRefBase>();
if (sceneRef.Length <= 0)
{
return;
}
ManagedLog.Log($"Loading main scene to test {SceneManager.GetActiveScene().name}");
var testingScene = AssetDatabase.LoadAssetAtPath <SceneAsset>(SceneManager.GetActiveScene().path);
GameWindow.TestLevel = AssetDatabase.LoadAssetAtPath <SceneAsset>(SceneManager.GetActiveScene().path);
_asyncOperation = EditorSceneManager.LoadSceneAsyncInPlayMode(GameWindow.MainSceneAssetPath,
new LoadSceneParameters(LoadSceneMode.Single));
_asyncOperation.completed += OnloadComplete;
void OnloadComplete(AsyncOperation obj)
{
game = FindAllObjects.InScene <GameBase>().FirstOrDefault();
_asyncOperation.completed -= OnloadComplete;
Assert.IsNotNull(game);
#if USING_SHAPES
WorldLog.OnScreen($"Testing {testingScene.name}");
#endif
new Operation(delay: 1f, action: () =>
{
game.StartGame();
}).Start();
}
}
internal static void RegisterViewOrController(Object obj)
{
switch (obj)
{
case View view:
Views.Add(view);
break;
case ControllerBase controllerBase:
Controllers.Add(controllerBase);
break;
default:
return;
}
ManagedLog.Log($"Registered new {obj.GetType().Name} ({obj.GetScenePath()})", ManagedLog.Type.Structure);
}
internal void InternalOnLevelStart(MainSceneRefBase levelData, TLevelSceneRefBase levelSceneRef)
{
ManagedLog.Log($"{GetType().Name}.{nameof(InternalOnLevelStart)} ({this.GetScenePath()})",
ManagedLog.Type.Verbose);
OnLevelDidStart(levelData as TMainSceneRefBase, levelSceneRef);
}
internal void InternalOnLevelStop()
{
ManagedLog.Log($"{GetType().Name}.{nameof(InternalOnLevelStop)} ({this.GetScenePath()})",
ManagedLog.Type.Verbose);
OnLevelDidStop();
}
// Disabled for now
/*
#region Access Restriction
*
* // ReSharper disable once InconsistentNaming
* public new GameObject gameObject
* {
* get
* {
* Debug.LogWarning($"Shouldn't access {nameof(gameObject)} of {nameof(ControllerBase)}");
* return base.gameObject;
* }
* }
*
* // ReSharper disable once InconsistentNaming
* public new Transform transform
* {
* get
* {
*
* Debug.LogWarning($"Shouldn't access {nameof(transform)} of {nameof(ControllerBase)}");
* return base.transform;
* }
* }
*
* // ReSharper disable once InconsistentNaming
* public new bool enabled
* {
* get
* {
* Debug.LogWarning($"Shouldn't access {nameof(enabled)} of {nameof(ControllerBase)}");
* return base.enabled;
* }
* set
* {
* Debug.LogWarning($"Shouldn't access {nameof(enabled)} of {nameof(ControllerBase)}");
* base.enabled = value;
* }
* }
*
#endregion
*/
#region Logging Helper Methods
protected void Log(object obj, ManagedLog.Type type = ManagedLog.Type.Default, Object context = null) => ManagedLog.Log(obj, type, context ? context : this);
protected void LogMethod(object obj = null, ManagedLog.Type type = ManagedLog.Type.Default, Object context = null) => ManagedLog.LogMethod(obj: obj, type: type, context: context, stackOffset: 1);
private static void LogTimeScale() => ManagedLog.Log($"TimeScale: {Time.timeScale}", avoidFrameCount: true);
private void LogMethodTest()
{
ManagedLog.LogMethod();
}
private static void SceneManagerOnSceneUnloaded(Scene arg0)
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
Views.RemoveAll(view => !view);
Controllers.RemoveAll(controllerBase => !controllerBase);
}
// This doesn't get called for initial scene in builds.
private static void SceneManagerOnSceneLoaded(Scene scene, LoadSceneMode arg1)
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
AddAllManagedObjectsInScene(scene);
// TODO: We need to keep track of newly instantiated views and destroyed ones
}
private static void InitializeOnEnterPlayMode()
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
Controllers.Clear();
Views.Clear();
}
private static void InitializeOnEnterPlayMode(EnterPlayModeOptions options)
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
StateMachines.Clear();
}
private static void InitializeOnLoadMethod()
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
EditorSceneManager.activeSceneChangedInEditMode += OnActiveSceneChangedInEditMode;
InitScene(SceneManager.GetActiveScene());
}
private static void Log(object msg)
{
ManagedLog.LogMethod(msg, color: Colors.PowderBlue, type: ManagedLog.Type.Structure, stackOffset: 1);
}
private static void InitializeOnLoadMethod()
{
ManagedLog.LogMethod(type: ManagedLog.Type.Structure);
PlayerLoopUtilities.AppendToPlayerLoop <Update.ScriptRunBehaviourUpdate>(typeof(ManagedLog), LateUpdate);
}
