public static bool LaunchMeteor(MeteorLauncher __instance)
        {
            var flag = __instance._dynamicMeteorPool != null && (__instance._meteorPool == null || Random.value < __instance._dynamicProbability);
            MeteorController meteorController = null;

            if (!flag)
            {
                if (__instance._meteorPool.Count == 0)
                {
                    Debug.LogWarning("MeteorLauncher is out of Meteors!", __instance);
                }
                else
                {
                    meteorController = __instance._meteorPool[__instance._meteorPool.Count - 1];
                    meteorController.Initialize(__instance.transform, __instance._detectableField, __instance._detectableFluid);
                    __instance._meteorPool.QuickRemoveAt(__instance._meteorPool.Count - 1);
                    __instance._launchedMeteors.Add(meteorController);
                }
            }
            else
            {
                if (__instance._dynamicMeteorPool.Count == 0)
                {
                    Debug.LogWarning("MeteorLauncher is out of Dynamic Meteors!", __instance);
                }
                else
                {
                    meteorController = __instance._dynamicMeteorPool[__instance._dynamicMeteorPool.Count - 1];
                    meteorController.Initialize(__instance.transform, null, null);
                    __instance._dynamicMeteorPool.QuickRemoveAt(__instance._dynamicMeteorPool.Count - 1);
                    __instance._launchedDynamicMeteors.Add(meteorController);
                }
            }

            if (meteorController != null)
            {
                var qsbMeteorLauncher = __instance.GetWorldObject <QSBMeteorLauncher>();
                var qsbMeteor         = meteorController.GetWorldObject <QSBMeteor>();

                qsbMeteorLauncher.MeteorId    = qsbMeteor.ObjectId;
                qsbMeteorLauncher.LaunchSpeed = Random.Range(__instance._minLaunchSpeed, __instance._maxLaunchSpeed);

                var linearVelocity  = __instance._parentBody.GetPointVelocity(__instance.transform.position) + (__instance.transform.TransformDirection(__instance._launchDirection) * qsbMeteorLauncher.LaunchSpeed);
                var angularVelocity = __instance.transform.forward * 2f;
                meteorController.Launch(null, __instance.transform.position, __instance.transform.rotation, linearVelocity, angularVelocity);
                if (__instance._audioSector.ContainsOccupant(DynamicOccupant.Player))
                {
                    __instance._launchSource.pitch = Random.Range(0.4f, 0.6f);
                    __instance._launchSource.PlayOneShot(AudioType.BH_MeteorLaunch);
                }

                qsbMeteorLauncher.SendMessage(new MeteorLaunchMessage(qsbMeteorLauncher));
            }

            return(false);
        }
        public static bool LaunchMeteor(MeteorLauncher __instance)
        {
            var qsbMeteorLauncher = __instance.GetWorldObject <QSBMeteorLauncher>();

            MeteorController meteorController = null;
            QSBMeteor        qsbMeteor;

            bool MeteorMatches(MeteorController x)
            {
                qsbMeteor = x.GetWorldObject <QSBMeteor>();
                return(qsbMeteor.ObjectId == qsbMeteorLauncher.MeteorId);
            }

            if (__instance._meteorPool != null)
            {
                meteorController = __instance._meteorPool.Find(MeteorMatches);
                if (meteorController != null)
                {
                    meteorController.Initialize(__instance.transform, __instance._detectableField, __instance._detectableFluid);
                }
            }
            else if (__instance._dynamicMeteorPool != null)
            {
                meteorController = __instance._dynamicMeteorPool.Find(MeteorMatches);
                if (meteorController != null)
                {
                    meteorController.Initialize(__instance.transform, null, null);
                }
            }

            if (meteorController != null)
            {
                var linearVelocity  = __instance._parentBody.GetPointVelocity(__instance.transform.position) + (__instance.transform.TransformDirection(__instance._launchDirection) * qsbMeteorLauncher.LaunchSpeed);
                var angularVelocity = __instance.transform.forward * 2f;
                meteorController.Launch(null, __instance.transform.position, __instance.transform.rotation, linearVelocity, angularVelocity);
                if (__instance._audioSector.ContainsOccupant(DynamicOccupant.Player))
                {
                    __instance._launchSource.pitch = Random.Range(0.4f, 0.6f);
                    __instance._launchSource.PlayOneShot(AudioType.BH_MeteorLaunch);
                }
            }
            else
            {
                DebugLog.ToConsole($"{qsbMeteorLauncher} - could not find meteor {qsbMeteorLauncher.MeteorId} in pool", MessageType.Warning);
            }

            return(false);
        }
        public static bool FixedUpdate(MeteorLauncher __instance)
        {
            if (!QSBWorldSync.AllObjectsReady)
            {
                return(true);
            }

            if (__instance._launchedMeteors != null)
            {
                for (var i = __instance._launchedMeteors.Count - 1; i >= 0; i--)
                {
                    if (__instance._launchedMeteors[i] == null)
                    {
                        __instance._launchedMeteors.QuickRemoveAt(i);
                    }
                    else if (__instance._launchedMeteors[i].isSuspended)
                    {
                        __instance._meteorPool.Add(__instance._launchedMeteors[i]);
                        __instance._launchedMeteors.QuickRemoveAt(i);
                    }
                }
            }

            if (__instance._launchedDynamicMeteors != null)
            {
                for (var j = __instance._launchedDynamicMeteors.Count - 1; j >= 0; j--)
                {
                    if (__instance._launchedDynamicMeteors[j] == null)
                    {
                        __instance._launchedDynamicMeteors.QuickRemoveAt(j);
                    }
                    else if (__instance._launchedDynamicMeteors[j].isSuspended)
                    {
                        __instance._dynamicMeteorPool.Add(__instance._launchedDynamicMeteors[j]);
                        __instance._launchedDynamicMeteors.QuickRemoveAt(j);
                    }
                }
            }

            if (__instance._initialized && Time.time > __instance._lastLaunchTime + __instance._launchDelay)
            {
                if (!__instance._areParticlesPlaying)
                {
                    __instance._areParticlesPlaying = true;
                    foreach (var particleSystem in __instance._launchParticles)
                    {
                        particleSystem.Play();
                    }

                    var qsbMeteorLauncher = __instance.GetWorldObject <QSBMeteorLauncher>();
                    qsbMeteorLauncher.SendMessage(new MeteorPreLaunchMessage());
                }

                if (Time.time > __instance._lastLaunchTime + __instance._launchDelay + 2.3f)
                {
                    __instance.LaunchMeteor();
                    __instance._lastLaunchTime      = Time.time;
                    __instance._launchDelay         = Random.Range(__instance._minInterval, __instance._maxInterval);
                    __instance._areParticlesPlaying = false;
                    foreach (var particleSystem in __instance._launchParticles)
                    {
                        particleSystem.Stop();
                    }
                }
            }

            return(false);
        }
 public static bool FixedUpdate(MeteorLauncher __instance)
 => false;