Example #1
0
        private static void RuntimeInitializeOnLoadBeforeSceneLoad()
        {
            UnityThread.RuntimeInitialize();

            Ensure.OnRuntimeMethodLoad();

            Recursion.OnRuntimeMethodLoad();

            OptimizedReflection.OnRuntimeMethodLoad();

            SavedVariables.OnEnterPlayMode();

            ApplicationVariables.OnEnterPlayMode();

            ReferenceCollector.Initialize();
        }
        public bool IsPredictable(Recursion recursion)
        {
            if (unit.isControlRoot)
            {
                return(true);
            }

            if (!recursion?.TryEnter(this) ?? false)
            {
                return(false);
            }

            var isPredictable = unit.relations.WithDestination(this).Where(r => r.source is ControlInput).All(r => ((ControlInput)r.source).IsPredictable(recursion));

            recursion?.Exit(this);

            return(isPredictable);
        }
        public bool IsPredictable(Recursion recursion)
        {
            if (!hasValidConnection)
            {
                return(true);
            }

            if (!recursion?.TryEnter(this) ?? false)
            {
                return(false);
            }

            var isPredictable = validConnectedPorts.All(cop => cop.IsPredictable(recursion));

            recursion?.Exit(this);

            return(isPredictable);
        }
        protected override bool IsTraversed()
        {
            var graph = transition.nest.graph;

            if (graph == null)
            {
                return(false);
            }

            using (var recursion = Recursion.New(1))
            {
                foreach (var trigger in graph.GetUnitsRecursive(recursion).OfType <TriggerStateTransition>())
                {
                    if (trigger.Analysis <UnitAnalysis>(context).isEntered)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
        private static IEnumerable <string> GetScriptGuids(Recursion recursion, Type type)
        {
            if (!recursion?.TryEnter(type) ?? false)
            {
                yield break;
            }

            if (typesToGuids.ContainsKey(type))
            {
                foreach (var guid in typesToGuids[type])
                {
                    yield return(guid);
                }
            }

            // Recurse inside the type.
            // For example, a List<Enemy> or an Enemy[] type should return the script GUID for Enemy.
            if (type.IsGenericType)
            {
                foreach (var genericArgument in type.GetGenericArguments())
                {
                    foreach (var genericGuid in GetScriptGuids(recursion, genericArgument))
                    {
                        yield return(genericGuid);
                    }
                }
            }
            else if (type.HasElementType)
            {
                foreach (var genericGuid in GetScriptGuids(recursion, type.GetElementType()))
                {
                    yield return(genericGuid);
                }
            }

            recursion?.Exit(type);
        }
Example #6
0
        public static IEnumerable <IUnit> GetUnitsRecursive(this FlowGraph flowGraph, Recursion recursion)
        {
            Ensure.That(nameof(flowGraph)).IsNotNull(flowGraph);

            if (!recursion?.TryEnter(flowGraph) ?? false)
            {
                yield break;
            }

            foreach (var unit in flowGraph.units)
            {
                yield return(unit);

                var nestedGraph = (unit as SubgraphUnit)?.nest.graph;

                if (nestedGraph != null)
                {
                    foreach (var nestedUnit in GetUnitsRecursive(nestedGraph, recursion))
                    {
                        yield return(nestedUnit);
                    }
                }
            }

            recursion?.Exit(flowGraph);
        }
Example #7
0
        void IPoolable.New()
        {
            disposed = false;

            recursion = Recursion <RecursionNode> .New();
        }