public void Update()
            {
                if (this.pulseIndicator)
                {
                    float num = this.radius * novaRadiusCurve.Evaluate(Time.fixedDeltaTime / duration);
                    this.pulseIndicator.localScale = new Vector3(num, num, num);
                }
#if DEBUG
                TurboEdition._logger.LogWarning("Updating " + this);
#endif

                this.time += this.rate * Time.deltaTime;
                this.time  = ((this.time > 1f) ? 1f : this.time);

#if DEBUG
                TurboEdition._logger.LogWarning("Updating sphereSearch radius, current time: " + time);
#endif

                sphereSearch.radius = finalRadius * novaRadiusCurve.Evaluate(this.time); //NRE, NEEDS SOMETHING INSTANTIATED

#if DEBUG
                TurboEdition._logger.LogWarning("Updating sphereSearch candidates, current radius: " + finalRadius);
#endif
                sphereSearch.RefreshCandidates().FilterCandidatesByHurtBoxTeam(this.enemyTeams).OrderCandidatesByDistance().FilterCandidatesByDistinctHurtBoxEntities().GetHurtBoxes(this.hurtBoxesList);

                int i     = 0;
                int count = this.hurtBoxesList.Count;
                while (i < count)
                {
                    HealthComponent healthComponent = this.hurtBoxesList[i].healthComponent;
                    if (!this.debuffedTargets.Contains(healthComponent))
                    {
#if DEBUG
                        TurboEdition._logger.LogWarning("Debuffing somebody: " + healthComponent.body);
#endif
                        this.debuffedTargets.Add(healthComponent);
                        this.DebuffTarget(healthComponent.body);
                    }
                    i++;
                }
#if DEBUG
                TurboEdition._logger.LogWarning("Done debuffing, clearing hurtboxes list.");
#endif
                this.hurtBoxesList.Clear();
            }
            public void Update()
            {
                // The charge fraction is synced over network only every few frames, so the animation becomes laggy
                // Predict the teleporter charge locally to make it smooth
                predictionChargeFractionDeltaTime += Time.deltaTime;
                float num = holdoutZoneController.charge - predictionChargeFractionLast;

                if (num != 0f)
                {
                    chargeFraction                    = holdoutZoneController.charge;
                    predictionChargeSpeed             = num / predictionChargeFractionDeltaTime;
                    predictionChargeFractionDeltaTime = 0f;
                }
                predictionChargeFractionLast = holdoutZoneController.charge;
                chargeFraction = Mathf.Clamp01(chargeFraction + predictionChargeSpeed * Time.deltaTime);

                int itemCount = Util.GetItemCountForTeam(TeamIndex.Player, MysticsItemsContent.Items.MysticsItems_CrystalWorld.itemIndex, true);

                if (itemCount > 0)
                {
                    float nextPulse = NextPulse(pulses + pulsesPerStack * (itemCount - 1));
                    if (!holdoutZoneController.enabled)
                    {
                        nextPulse = 100f;
                    }
                    if (nextPulse >= 1f)
                    {
                        nextPulse = 100f;
                    }

                    float t = (1f - (nextPulse - chargeFraction) / windup) * 0.5f;
                    if (chargeFraction <= (prevPulse + winddown))
                    {
                        t = ((chargeFraction - prevPulse) / winddown) * 0.5f + 0.5f;
                    }
                    t = Mathf.Clamp01(t);

                    currentSpin   = finalSpin * animationCurve.Evaluate(t);
                    currentHeight = finalHeight * animationCurve.Evaluate(t);
                    if (model)
                    {
                        if (!model.activeSelf)
                        {
                            model.SetActive(true);
                        }
                        model.transform.Rotate(new Vector3(0f, currentSpin * Time.deltaTime, 0f), Space.Self);
                        model.transform.localPosition = offset + Vector3.up * currentHeight;
                    }

                    if (holdoutZoneController.charge > nextPulse)
                    {
                        prevPulse = nextPulse;
                        if (NetworkServer.active)
                        {
                            EffectManager.SpawnEffect(pulsePrefab, new EffectData
                            {
                                origin = transform.position,
                                scale  = holdoutZoneController.currentRadius * 2f
                            }, true);
                            sphereSearch.radius = holdoutZoneController.currentRadius;
                            foreach (HurtBox hurtBox in sphereSearch.RefreshCandidates().FilterCandidatesByHurtBoxTeam(teamMask).FilterCandidatesByDistinctHurtBoxEntities().GetHurtBoxes())
                            {
                                HealthComponent healthComponent = hurtBox.healthComponent;
                                if (healthComponent)
                                {
                                    CharacterBody body = healthComponent.body;
                                    if (body)
                                    {
                                        SetStateOnHurt setStateOnHurt = body.gameObject.GetComponent <SetStateOnHurt>();
                                        if (setStateOnHurt && setStateOnHurt.canBeFrozen)
                                        {
                                            setStateOnHurt.SetFrozen(freezeTime);

                                            // Deal a bit of damage to force execute
                                            DamageInfo damageInfo = new DamageInfo
                                            {
                                                attacker        = null,
                                                damage          = 12f * 2.4f * TeamManager.instance.GetTeamLevel(TeamIndex.Player),
                                                procCoefficient = 0f,
                                                position        = hurtBox.transform.position,
                                                crit            = false
                                            };
                                            healthComponent.TakeDamage(damageInfo);
                                        }
                                        else
                                        {
                                            body.AddTimedBuff(MysticsItemsContent.Buffs.MysticsItems_Crystallized, freezeTime);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (model && model.activeSelf)
                    {
                        model.SetActive(false);
                    }
                }
            }