示例#1
0
        /// /////////////////////////////////////////////////////////
        /// Methods
        /// /////////////////////////////////////////////////////////

        // Init restriction check
        public static void InitRestriction(RayfireRigid scr)
        {
            if (scr.restriction == null)
            {
                return;
            }

            // No action required
            if (scr.restriction.enable == false)
            {
                return;
            }

            // Already broke
            if (scr.restriction.broke == true)
            {
                return;
            }

            // Init distance check
            if (scr.restriction.distance > 0)
            {
                // Init position distance
                if (scr.restriction.position == RFDistanceType.InitializePosition)
                {
                    scr.StartCoroutine(RestrictionDistanceCor(scr));
                }

                // Init target position
                else
                {
                    if (scr.restriction.target != null)
                    {
                        scr.StartCoroutine(RestrictionDistanceCor(scr));
                    }
                    else
                    {
                        Debug.Log("Target is not defined", scr.gameObject);
                    }
                }
            }

            // Init trigger check
            if (scr.restriction.Collider != null)
            {
                // Check if trigger
                if (scr.restriction.Collider.isTrigger == false)
                {
                    Debug.Log("Collider is not trigger", scr.gameObject);
                }

                // Init
                scr.StartCoroutine(RestrictionTriggerCor(scr));
            }
        }
示例#2
0
        // Fading init for fragment objects
        public static void Fade(RayfireRigid scr)
        {
            // Initialize if not
            if (scr.initialized == false)
            {
                scr.Initialize();
            }

            // No fading
            if (scr.fading.fadeType == FadeType.None)
            {
                return;
            }

            // Object inactive, SKip
            if (scr.gameObject.activeSelf == false)
            {
                return;
            }

            // Object living, fading or faded
            if (scr.fading.state > 0)
            {
                return;
            }

            // Start life coroutine
            scr.StartCoroutine(scr.fading.LivingCor(scr));
        }
示例#3
0
        /// /////////////////////////////////////////////////////////
        /// Methods
        /// /////////////////////////////////////////////////////////

        // Start collapse
        public static void StartCollapse(RayfireRigid scr)
        {
            // Not initialized
            if (scr.initialized == false)
            {
                return;
            }

            // Already running
            if (scr.clusterDemolition.collapse.inProgress == true)
            {
                return;
            }

            // Not enough shards
            if (scr.clusterDemolition.cluster.shards.Count <= 1)
            {
                return;
            }

            scr.StartCoroutine(scr.clusterDemolition.collapse.CollapseCor(scr));
        }
示例#4
0
        /// /////////////////////////////////////////////////////////
        /// Coroutines
        /// /////////////////////////////////////////////////////////

        // Start life coroutine
        IEnumerator LivingCor(RayfireRigid scr)
        {
            // Wait for simulation get rest
            if (scr.fading.lifeType == RFFadeLifeType.BySimulationAndLifeTime)
            {
                yield return(scr.StartCoroutine(SimulationCor(scr)));
            }

            // Set living
            scr.fading.state = 1;

            // Get final life duration
            float lifeDuration = scr.fading.lifeTime;

            if (scr.fading.lifeVariation > 0)
            {
                lifeDuration += Random.Range(0f, scr.fading.lifeVariation);
            }

            // Wait life time
            if (lifeDuration > 0)
            {
                yield return(new WaitForSeconds(lifeDuration));
            }

            // Stop fading
            if (stop == true)
            {
                scr.fading.Reset();
                yield break;
            }

            // Set fading
            scr.fading.state = 2;

            // TODO MAKE RESETABLE
            // scr.reset.action = RFReset.PostDemolitionType.DestroyWithDelay;

            // Exclude from simulation and keep object in scene
            if (scr.fading.fadeType == FadeType.SimExclude)
            {
                FadeExclude(scr);
            }

            // Exclude from simulation, move under ground, destroy
            else if (scr.fading.fadeType == FadeType.MoveDown)
            {
                scr.StartCoroutine(FadeMoveDown(scr));
            }

            // Start scale down and destroy
            else if (scr.fading.fadeType == FadeType.ScaleDown)
            {
                scr.StartCoroutine(FadeScaleDownCor(scr));
            }

            // Destroy object
            else if (scr.fading.fadeType == FadeType.Destroy)
            {
                RayfireMan.DestroyFragment(scr, scr.rootParent);
            }
        }