Example #1
0
 // Token: 0x06000DBE RID: 3518 RVA: 0x00043874 File Offset: 0x00041A74
 private void Simulate(float deltaTime)
 {
     if (this.targetPlayers)
     {
         this.playerRetargetTimer -= deltaTime;
         if (this.playerRetargetTimer <= 0f)
         {
             this.playerRetargetTimer = this.rng.RangeFloat(1f, 10f);
             this.PickPlayerAsSpawnTarget();
         }
     }
     this.monsterSpawnTimer -= deltaTime;
     if (this.monsterSpawnTimer <= 0f)
     {
         bool flag = false;
         if (TeamComponent.GetTeamMembers(TeamIndex.Monster).Count < 40 || this.isBoss)
         {
             flag = this.AttemptSpawnOnTarget(this.currentSpawnTarget);
         }
         if (flag)
         {
             if (this.shouldSpawnOneWave)
             {
                 this.hasStartedWave = true;
             }
             this.monsterSpawnTimer += this.rng.RangeFloat(this.minSeriesSpawnInterval, this.maxSeriesSpawnInterval);
             return;
         }
         this.monsterSpawnTimer += this.rng.RangeFloat(this.minRerollSpawnInterval, this.maxRerollSpawnInterval);
         this.currentMonsterCard = null;
         if (this.shouldSpawnOneWave && this.hasStartedWave)
         {
             base.enabled = false;
             return;
         }
     }
 }
 private void AttemptGrant(CharacterBody body)
 {
     if (!NetworkServer.active)
     {
         Debug.LogWarning("[Server] function 'System.Void RoR2.GenericPickupController::AttemptGrant(RoR2.CharacterBody)' called on client");
         return;
     }
     foreach (TeamComponent component in TeamComponent.GetTeamMembers(TeamIndex.Player))
     {
         body = component.GetComponent <CharacterBody>();
         if (component && component.teamIndex == TeamIndex.Player)
         {
             Inventory inventory = body.inventory;
             if (inventory)
             {
                 this.consumed = true;
                 PickupDef pickupDef = PickupCatalog.GetPickupDef(this.pickupIndex);
                 if (pickupDef.itemIndex != ItemIndex.None)
                 {
                     this.GrantItem(body, inventory);
                 }
                 if (pickupDef.equipmentIndex != EquipmentIndex.None)
                 {
                     this.GrantEquipment(body, inventory);
                 }
                 if (pickupDef.artifactIndex != ArtifactIndex.None)
                 {
                     this.GrantArtifact(body, pickupDef.artifactIndex);
                 }
                 if (pickupDef.coinValue != 0U)
                 {
                     this.GrantLunarCoin(body, pickupDef.coinValue);
                 }
             }
         }
     }
 }
        // Token: 0x06000C12 RID: 3090 RVA: 0x0003BE4C File Offset: 0x0003A04C
        private Transform FindTarget()
        {
            TeamIndex teamIndex  = TeamIndex.Monster;
            TeamIndex teamIndex2 = this.teamFilter.teamIndex;

            if (teamIndex2 != TeamIndex.Player)
            {
                if (teamIndex2 == TeamIndex.Monster)
                {
                    teamIndex = TeamIndex.Player;
                }
            }
            else
            {
                teamIndex = TeamIndex.Monster;
            }
            ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(teamIndex);
            float     num      = 99999f;
            Transform result   = null;
            Vector3   position = this.transform.position;

            for (int i = 0; i < teamMembers.Count; i++)
            {
                Transform transform = teamMembers[i].transform;
                if (!this.pastTargetList.Contains(transform) || (this.canBounceToSameTarget && transform != this.lastTarget))
                {
                    float num2 = Vector3.SqrMagnitude(transform.position - position);
                    if (num2 < num && (!this.smartSeeking || !Physics.Raycast(position, transform.position - position, Mathf.Sqrt(num2), LayerIndex.world.mask)) && num2 <= this.maxChainDistance * this.maxChainDistance)
                    {
                        num    = num2;
                        result = transform;
                    }
                }
            }
            return(result);
        }
Example #4
0
        // Token: 0x06000D1E RID: 3358 RVA: 0x00040DA8 File Offset: 0x0003EFA8
        private void UpdateForCamera(CameraRigController cameraRigController)
        {
            this.visibility = VisibilityLevel.Visible;
            bool  flag   = false;
            float target = 1f;

            if (this.body)
            {
                if (flag)
                {
                    target = 0f;
                }
                if (this.body.HasBuff(BuffIndex.Cloak))
                {
                    TeamIndex     teamIndex = TeamIndex.Neutral;
                    TeamComponent component = this.body.GetComponent <TeamComponent>();
                    if (component)
                    {
                        teamIndex = component.teamIndex;
                    }
                    this.visibility = ((cameraRigController.targetTeamIndex == teamIndex) ? VisibilityLevel.Revealed : VisibilityLevel.Cloaked);
                }
            }
            this.firstPersonFade = Mathf.MoveTowards(this.firstPersonFade, target, Time.deltaTime / 0.25f);
            this.fade           *= this.firstPersonFade;
            if (this.fade <= 0f || this.invisibilityCount > 0)
            {
                this.visibility = VisibilityLevel.Invisible;
            }
            this.UpdateOverlays();
            if (this.materialsDirty)
            {
                this.UpdateMaterials();
                this.materialsDirty = false;
            }
        }
Example #5
0
        // Token: 0x06000426 RID: 1062 RVA: 0x00010B54 File Offset: 0x0000ED54
        public bool DefaultHitCallback(ref BulletAttack.BulletHit hitInfo)
        {
            bool result = false;

            if (hitInfo.collider)
            {
                result = ((1 << hitInfo.collider.gameObject.layer & this.stopperMask) == 0);
            }
            if (this.hitEffectPrefab)
            {
                EffectManager.SimpleImpactEffect(this.hitEffectPrefab, hitInfo.point, this.HitEffectNormal ? hitInfo.surfaceNormal : (-hitInfo.direction), true);
            }
            if (hitInfo.collider)
            {
                SurfaceDef objectSurfaceDef = SurfaceDefProvider.GetObjectSurfaceDef(hitInfo.collider, hitInfo.point);
                if (objectSurfaceDef && objectSurfaceDef.impactEffectPrefab)
                {
                    EffectData effectData = new EffectData
                    {
                        origin          = hitInfo.point,
                        rotation        = Quaternion.LookRotation(hitInfo.surfaceNormal),
                        color           = objectSurfaceDef.approximateColor,
                        surfaceDefIndex = objectSurfaceDef.surfaceDefIndex
                    };
                    EffectManager.SpawnEffect(objectSurfaceDef.impactEffectPrefab, effectData, true);
                }
            }
            if (this.isCrit)
            {
                EffectManager.SimpleImpactEffect(Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/Critspark"), hitInfo.point, this.HitEffectNormal ? hitInfo.surfaceNormal : (-hitInfo.direction), true);
            }
            GameObject entityObject = hitInfo.entityObject;

            if (entityObject)
            {
                float num = 1f;
                switch (this.falloffModel)
                {
                case BulletAttack.FalloffModel.None:
                    num = 1f;
                    break;

                case BulletAttack.FalloffModel.DefaultBullet:
                    num = 0.5f + Mathf.Clamp01(Mathf.InverseLerp(60f, 25f, hitInfo.distance)) * 0.5f;
                    break;

                case BulletAttack.FalloffModel.Buckshot:
                    num = 0.25f + Mathf.Clamp01(Mathf.InverseLerp(25f, 7f, hitInfo.distance)) * 0.75f;
                    break;
                }
                DamageInfo damageInfo = new DamageInfo();
                damageInfo.damage           = this.damage * num;
                damageInfo.crit             = this.isCrit;
                damageInfo.attacker         = this.owner;
                damageInfo.inflictor        = this.weapon;
                damageInfo.position         = hitInfo.point;
                damageInfo.force            = hitInfo.direction * (this.force * num);
                damageInfo.procChainMask    = this.procChainMask;
                damageInfo.procCoefficient  = this.procCoefficient;
                damageInfo.damageType       = this.damageType;
                damageInfo.damageColorIndex = this.damageColorIndex;
                damageInfo.ModifyDamageInfo(hitInfo.damageModifier);
                TeamIndex teamIndex = TeamIndex.Neutral;
                if (this.owner)
                {
                    TeamComponent component = this.owner.GetComponent <TeamComponent>();
                    if (component)
                    {
                        teamIndex = component.teamIndex;
                    }
                }
                TeamIndex     teamIndex2 = TeamIndex.Neutral;
                TeamComponent component2 = hitInfo.entityObject.GetComponent <TeamComponent>();
                if (component2)
                {
                    teamIndex2 = component2.teamIndex;
                }
                bool            flag            = teamIndex == teamIndex2;
                HealthComponent healthComponent = null;
                if (!flag)
                {
                    healthComponent = entityObject.GetComponent <HealthComponent>();
                }
                if (NetworkServer.active)
                {
                    if (healthComponent)
                    {
                        healthComponent.TakeDamage(damageInfo);
                        GlobalEventManager.instance.OnHitEnemy(damageInfo, hitInfo.entityObject);
                    }
                    GlobalEventManager.instance.OnHitAll(damageInfo, hitInfo.entityObject);
                }
                else if (ClientScene.ready)
                {
                    BulletAttack.messageWriter.StartMessage(53);
                    BulletAttack.messageWriter.Write(entityObject);
                    BulletAttack.messageWriter.Write(damageInfo);
                    BulletAttack.messageWriter.Write(healthComponent != null);
                    BulletAttack.messageWriter.FinishMessage();
                    ClientScene.readyConnection.SendWriter(BulletAttack.messageWriter, QosChannelIndex.defaultReliable.intVal);
                }
            }
            return(result);
        }
Example #6
0
        // Token: 0x06001C39 RID: 7225 RVA: 0x00083F04 File Offset: 0x00082104
        public static CharacterBody GetEnemyEasyTarget(CharacterBody casterBody, Ray aimRay, float maxDistance, float maxDeviation = 20f)
        {
            TeamIndex     teamIndex = TeamIndex.Neutral;
            TeamComponent component = casterBody.GetComponent <TeamComponent>();

            if (component)
            {
                teamIndex = component.teamIndex;
            }
            List <TeamComponent> list = new List <TeamComponent>();

            for (TeamIndex teamIndex2 = TeamIndex.Neutral; teamIndex2 < TeamIndex.Count; teamIndex2 += 1)
            {
                if (teamIndex2 != teamIndex)
                {
                    list.AddRange(TeamComponent.GetTeamMembers(teamIndex2));
                }
            }
            Vector3 origin    = aimRay.origin;
            Vector3 direction = aimRay.direction;
            List <Util.EasyTargetCandidate> candidatesList = new List <Util.EasyTargetCandidate>(list.Count);
            List <int> list2 = new List <int>(list.Count);
            float      num   = Mathf.Cos(maxDeviation * 0.017453292f);

            for (int i = 0; i < list.Count; i++)
            {
                Transform     transform  = list[i].transform;
                Vector3       a2         = transform.position - origin;
                float         magnitude  = a2.magnitude;
                float         num2       = Vector3.Dot(a2 * (1f / magnitude), direction);
                CharacterBody component2 = transform.GetComponent <CharacterBody>();
                if (num2 >= num && component2 != casterBody && magnitude < maxDistance)
                {
                    float num3  = 1f / magnitude;
                    float score = num2 + num3;
                    candidatesList.Add(new Util.EasyTargetCandidate
                    {
                        transform = transform,
                        score     = score,
                        distance  = magnitude
                    });
                    list2.Add(list2.Count);
                }
            }
            list2.Sort(delegate(int a, int b)
            {
                float score2 = candidatesList[a].score;
                float score3 = candidatesList[b].score;
                if (score2 == score3)
                {
                    return(0);
                }
                if (score2 <= score3)
                {
                    return(1);
                }
                return(-1);
            });
            for (int j = 0; j < list2.Count; j++)
            {
                int           index      = list2[j];
                CharacterBody component3 = candidatesList[index].transform.GetComponent <CharacterBody>();
                if (component3 && component3 != casterBody)
                {
                    return(component3);
                }
            }
            return(null);
        }
 // Token: 0x06000BF5 RID: 3061 RVA: 0x000357D4 File Offset: 0x000339D4
 private void OnTriggerEnter(Collider other)
 {
     if (NetworkServer.active && !this.gravitateTarget && this.teamFilter.teamIndex != TeamIndex.None && TeamComponent.GetObjectTeam(other.gameObject) == this.teamFilter.teamIndex)
     {
         this.gravitateTarget = other.gameObject.transform;
     }
 }
 // Token: 0x06001014 RID: 4116 RVA: 0x00050B28 File Offset: 0x0004ED28
 public void FixedUpdate()
 {
     if (NetworkServer.active)
     {
         if (this.body)
         {
             this.regenAccumulator += this.body.regen * Time.fixedDeltaTime;
         }
         if (this.regenAccumulator > 1f)
         {
             float num = Mathf.Floor(this.regenAccumulator);
             this.regenAccumulator -= num;
             this.Heal(num, default(ProcChainMask), false);
         }
         if (this.alive && this.regenAccumulator < -1f)
         {
             float num2 = Mathf.Ceil(this.regenAccumulator);
             this.regenAccumulator -= num2;
             this.Networkhealth     = this.health + num2;
             if (this.health <= 0f)
             {
                 this.Suicide(null);
             }
         }
         bool flag = this.shield == this.body.maxShield;
         if (this.body.outOfDanger)
         {
             this.Networkshield = this.shield + this.body.maxShield * 0.5f * Time.fixedDeltaTime;
         }
         this.Networkshield = Mathf.Min(this.shield, this.body.maxShield);
         if (this.shield == this.body.maxShield && !flag)
         {
             Util.PlaySound("Play_item_proc_personal_shield_end", base.gameObject);
         }
         if (this.devilOrbHealPool > 0f)
         {
             this.devilOrbTimer -= Time.fixedDeltaTime;
             if (this.devilOrbTimer <= 0f)
             {
                 this.devilOrbTimer += 0.1f;
                 float scale = 1f;
                 float num3  = this.fullCombinedHealth / 10f;
                 float num4  = 2.5f;
                 this.devilOrbHealPool -= num3;
                 DevilOrb devilOrb = new DevilOrb();
                 devilOrb.origin           = this.body.aimOriginTransform.position;
                 devilOrb.damageValue      = num3 * num4;
                 devilOrb.teamIndex        = TeamComponent.GetObjectTeam(base.gameObject);
                 devilOrb.attacker         = base.gameObject;
                 devilOrb.damageColorIndex = DamageColorIndex.Poison;
                 devilOrb.scale            = scale;
                 devilOrb.procChainMask.AddProc(ProcType.HealNova);
                 HurtBox hurtBox = devilOrb.PickNextTarget(devilOrb.origin, 40f);
                 if (hurtBox)
                 {
                     devilOrb.target = hurtBox;
                     devilOrb.isCrit = Util.CheckRoll(this.body.crit, this.body.master);
                     OrbManager.instance.AddOrb(devilOrb);
                 }
             }
         }
     }
     if (this.combatHealthbarTransform)
     {
         this.combatHealthTimer -= Time.fixedDeltaTime;
         if (this.combatHealthTimer <= 0f || !this.alive || this.body.HasBuff(BuffIndex.Cloak))
         {
             this.combatHealthTimer = 0f;
             UnityEngine.Object.Destroy(this.combatHealthbarTransform.gameObject);
         }
     }
     if (!this.alive && this.wasAlive)
     {
         this.wasAlive = false;
         base.BroadcastMessage("OnDeath", null, SendMessageOptions.DontRequireReceiver);
     }
 }
        // Token: 0x06000BF9 RID: 3065 RVA: 0x0003B218 File Offset: 0x00039418
        private void UpdateCrosshair(Vector3 raycastStartPlanePoint)
        {
            this.lastAimAssist = this.aimAssist;
            Vector2 zero = Vector2.zero;
            Ray     crosshairRaycastRay = this.GetCrosshairRaycastRay(zero, raycastStartPlanePoint);
            bool    flag = false;

            this.lastCrosshairHurtBox = null;
            RaycastHit raycastHit = default(RaycastHit);

            RaycastHit[] array = Physics.RaycastAll(crosshairRaycastRay, this.maxAimRaycastDistance, LayerIndex.world.mask | LayerIndex.entityPrecise.mask, QueryTriggerInteraction.Ignore);
            float        num   = float.PositiveInfinity;
            int          num2  = -1;

            for (int i = 0; i < array.Length; i++)
            {
                RaycastHit raycastHit2 = array[i];
                HurtBox    component   = raycastHit2.collider.GetComponent <HurtBox>();
                float      distance    = raycastHit2.distance;
                if (distance < num && distance > 3f && (!component || !component.healthComponent || !component.healthComponent.body || component.healthComponent.body.teamComponent.teamIndex != this.targetTeamIndex))
                {
                    num  = distance;
                    num2 = i;
                    this.lastCrosshairHurtBox = component;
                }
            }
            if (num2 != -1)
            {
                flag       = true;
                raycastHit = array[num2];
            }
            this.aimAssist.aimAssistHurtbox = null;
            if (flag)
            {
                this.crosshairWorldPosition = raycastHit.point;
                float num3 = 1000f;
                if (raycastHit.distance < num3)
                {
                    HurtBox component2 = raycastHit.collider.GetComponent <HurtBox>();
                    if (component2)
                    {
                        HealthComponent healthComponent = component2.healthComponent;
                        if (healthComponent)
                        {
                            TeamComponent component3 = healthComponent.GetComponent <TeamComponent>();
                            if (component3 && component3.teamIndex != this.targetTeamIndex && component3.teamIndex != TeamIndex.None)
                            {
                                CharacterBody body    = healthComponent.body;
                                HurtBox       hurtBox = (body != null) ? body.mainHurtBox : null;
                                if (hurtBox)
                                {
                                    this.aimAssist.aimAssistHurtbox       = hurtBox;
                                    this.aimAssist.worldPosition          = raycastHit.point;
                                    this.aimAssist.localPositionOnHurtbox = hurtBox.transform.InverseTransformPoint(raycastHit.point);
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                this.crosshairWorldPosition = crosshairRaycastRay.GetPoint(this.maxAimRaycastDistance);
            }
        }
Example #10
0
        private void AddDot(GameObject attackerObject, float duration, DotController.DotIndex dotIndex, float damageMultiplier)
        {
            if (!NetworkServer.active)
            {
                Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::AddDot(UnityEngine.GameObject,System.Single,RoR2.DotController/DotIndex,System.Single)' called on client");
                return;
            }
            if (dotIndex < DotController.DotIndex.Bleed || dotIndex >= DotController.DotIndex.Count)
            {
                return;
            }
            TeamIndex     teamIndex = TeamIndex.Neutral;
            float         num       = 0f;
            TeamComponent component = attackerObject.GetComponent <TeamComponent>();

            if (component)
            {
                teamIndex = component.teamIndex;
            }
            CharacterBody component2 = attackerObject.GetComponent <CharacterBody>();

            if (component2)
            {
                num = component2.damage;
            }
            DotController.DotDef   dotDef   = DotController.dotDefs[(int)dotIndex];
            DotController.DotStack dotStack = new DotController.DotStack
            {
                dotIndex       = dotIndex,
                dotDef         = dotDef,
                attackerObject = attackerObject,
                attackerTeam   = teamIndex,
                timer          = duration,
                damage         = dotDef.damageCoefficient * num * damageMultiplier,
                damageType     = DamageType.Generic
            };
            if (dotIndex == DotController.DotIndex.Helfire)
            {
                if (!component2)
                {
                    return;
                }
                HealthComponent healthComponent = component2.healthComponent;
                if (!healthComponent)
                {
                    return;
                }
                dotStack.damage = healthComponent.fullHealth * 0.01f * damageMultiplier;
                if (this.victimObject == attackerObject)
                {
                    dotStack.damageType |= (DamageType.NonLethal | DamageType.Silent);
                }
                else if (this.victimTeam == teamIndex)
                {
                    dotStack.damage *= 0.5f;
                }
                else
                {
                    dotStack.damage *= 24f;
                }
                int i     = 0;
                int count = this.dotStackList.Count;
                while (i < count)
                {
                    if (this.dotStackList[i].dotIndex == DotController.DotIndex.Helfire && this.dotStackList[i].attackerObject == attackerObject)
                    {
                        this.dotStackList[i].timer  = Mathf.Max(this.dotStackList[i].timer, duration);
                        this.dotStackList[i].damage = dotStack.damage;
                        return;
                    }
                    i++;
                }
                if (this.victimBody)
                {
                    EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/HelfireIgniteEffect"), new EffectData
                    {
                        origin = this.victimBody.corePosition
                    }, true);
                }
            }
            this.dotStackList.Add(dotStack);
        }
        public void EndRound()
        {
            if (!NetworkServer.active)
            {
                Debug.LogWarning("[Server] function 'System.Void RoR2.ArenaMissionController::EndRound()' called on client");
                return;
            }
            int clearedRounds = this.clearedRounds;

            this.clearedRounds = clearedRounds + 1;
            if (this.currentRound < this.totalRoundsMax)
            {
                this.ReadyNextNullWard();
            }
            else
            {
                Action action = ArenaMissionController.onBeatArena;
                if (action != null)
                {
                    action();
                }
                this.mainStateMachine.SetNextState(new ArenaMissionController.MissionCompleted());
                Chat.SendBroadcastChat(new Chat.SimpleChatMessage
                {
                    baseToken = "ARENA_END"
                });
            }
            for (int i = 0; i < this.combatDirectors.Length; i++)
            {
                CombatDirector combatDirector = this.combatDirectors[i];
                combatDirector.enabled       = false;
                combatDirector.monsterCredit = 0f;
            }
            ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Monster);

            for (int j = teamMembers.Count - 1; j >= 0; j--)
            {
                teamMembers[j].body.healthComponent.Suicide(base.gameObject, base.gameObject, DamageType.VoidDeath);
            }
            int participatingPlayerCount = Run.instance.participatingPlayerCount;

            if (participatingPlayerCount != 0 && this.rewardSpawnPosition)
            {
                List <PickupIndex> list = Run.instance.availableTier1DropList;
                if (this.currentRound > 4)
                {
                    list = Run.instance.availableTier2DropList;
                }
                if (this.currentRound == this.totalRoundsMax)
                {
                    list = Run.instance.availableTier3DropList;
                }
                ItemIndex  itemIndex = this.rng.NextElementUniform <PickupIndex>(list).itemIndex;
                int        num       = participatingPlayerCount;
                float      angle     = 360f / (float)num;
                Vector3    vector    = Quaternion.AngleAxis((float)UnityEngine.Random.Range(0, 360), Vector3.up) * (Vector3.up * 40f + Vector3.forward * 5f);
                Quaternion rotation  = Quaternion.AngleAxis(angle, Vector3.up);
                int        k         = 0;
                while (k < num)
                {
                    PickupDropletController.CreatePickupDroplet(new PickupIndex(itemIndex), this.rewardSpawnPosition.transform.position, vector);
                    k++;
                    vector = rotation * vector;
                }
            }
        }
 // Token: 0x060011BD RID: 4541 RVA: 0x00057D31 File Offset: 0x00055F31
 private int CountEnemies()
 {
     return(TeamComponent.GetTeamMembers(TeamIndex.Monster).Count);
 }
 // Token: 0x060010A6 RID: 4262 RVA: 0x00052F28 File Offset: 0x00051128
 private void FixedUpdate()
 {
     if (this.cachedOwnerInfo.gameObject != this.owner)
     {
         this.cachedOwnerInfo = new IcicleAuraController.OwnerInfo(this.owner);
     }
     this.UpdateRadius();
     this.UpdatePosition();
     if (NetworkServer.active)
     {
         if (!this.owner)
         {
             UnityEngine.Object.Destroy(base.gameObject);
             return;
         }
         for (int i = this.icicleLifetimes.Count - 1; i >= 0; i--)
         {
             List <float> list  = this.icicleLifetimes;
             int          index = i;
             list[index] -= Time.fixedDeltaTime;
             if (this.icicleLifetimes[i] <= 0f)
             {
                 this.icicleLifetimes.RemoveAt(i);
             }
         }
         this.NetworkfinalIcicleCount = Mathf.Min((this.icicleLifetimes.Count > 0) ? (2 + this.icicleLifetimes.Count) : 0, 5);
         this.attackStopwatch        += Time.fixedDeltaTime;
     }
     if (this.cachedOwnerInfo.characterBody)
     {
         if (this.finalIcicleCount > 0)
         {
             if (this.lastIcicleCount == 0)
             {
                 this.OnIciclesActivated();
             }
             if (this.lastIcicleCount < this.finalIcicleCount)
             {
                 this.OnIcicleGained();
             }
         }
         else if (this.lastIcicleCount > 0)
         {
             this.OnIciclesDeactivated();
         }
         this.lastIcicleCount = this.finalIcicleCount;
     }
     if (NetworkServer.active && this.cachedOwnerInfo.characterBody && this.finalIcicleCount > 0)
     {
         float num = 0f;
         if (this.cachedOwnerInfo.characterBody.inventory)
         {
             num = 0.5f + 0.5f * (float)this.cachedOwnerInfo.characterBody.inventory.GetItemCount(ItemIndex.Icicle);
         }
         if (this.attackStopwatch >= 0.25f)
         {
             this.attackStopwatch = 0f;
             BlastAttack blastAttack = new BlastAttack();
             blastAttack.attacker         = this.owner;
             blastAttack.inflictor        = base.gameObject;
             blastAttack.teamIndex        = TeamComponent.GetObjectTeam(blastAttack.attacker);
             blastAttack.position         = this.transform.position;
             blastAttack.procCoefficient  = 0.05f;
             blastAttack.radius           = this.actualRadius;
             blastAttack.baseForce        = 0f;
             blastAttack.baseDamage       = num * 0.25f * this.cachedOwnerInfo.characterBody.damage * (float)this.finalIcicleCount;
             blastAttack.bonusForce       = Vector3.zero;
             blastAttack.crit             = false;
             blastAttack.damageType       = DamageType.Generic;
             blastAttack.falloffModel     = BlastAttack.FalloffModel.None;
             blastAttack.damageColorIndex = DamageColorIndex.Item;
             blastAttack.Fire();
         }
     }
 }
Example #14
0
        // Token: 0x0600162E RID: 5678 RVA: 0x0006A288 File Offset: 0x00068488
        private void SetupIndicator()
        {
            if (this.indicator)
            {
                return;
            }
            CharacterBody component = base.GetComponent <CharacterBody>();

            if (component)
            {
                TeamComponent component2 = component.GetComponent <TeamComponent>();
                if (component2)
                {
                    CharacterMaster master     = component.master;
                    bool            flag       = master && master.isBoss;
                    GameObject      gameObject = null;
                    if (master && component2.teamIndex == TeamIndex.Player)
                    {
                        bool flag2 = false;
                        PlayerCharacterMasterController component3 = master.GetComponent <PlayerCharacterMasterController>();
                        if (component3)
                        {
                            flag2 = true;
                            GameObject networkUserObject = component3.networkUserObject;
                            if (networkUserObject)
                            {
                                NetworkIdentity component4 = networkUserObject.GetComponent <NetworkIdentity>();
                                if (component4)
                                {
                                    bool isLocalPlayer = component4.isLocalPlayer;
                                }
                            }
                        }
                        Vector3 position = component.transform.position;
                        component.GetComponent <Collider>();
                        if (flag2)
                        {
                            gameObject = Resources.Load <GameObject>("Prefabs/PositionIndicators/PlayerPositionIndicator");
                        }
                        else
                        {
                            gameObject = Resources.Load <GameObject>("Prefabs/PositionIndicators/NPCPositionIndicator");
                        }
                        this.indicator = UnityEngine.Object.Instantiate <GameObject>(gameObject, position, Quaternion.identity, component.transform);
                    }
                    else if (flag)
                    {
                        gameObject = Resources.Load <GameObject>("Prefabs/PositionIndicators/BossPositionIndicator");
                    }
                    if (this.indicator)
                    {
                        UnityEngine.Object.Destroy(this.indicator);
                        this.indicator = null;
                    }
                    if (gameObject)
                    {
                        this.indicator = UnityEngine.Object.Instantiate <GameObject>(gameObject, base.transform);
                        this.indicator.GetComponent <PositionIndicator>().targetTransform = component.coreTransform;
                        Nameplate component5 = this.indicator.GetComponent <Nameplate>();
                        if (component5)
                        {
                            component5.SetBody(component);
                        }
                    }
                }
            }
        }
 // Token: 0x06001678 RID: 5752 RVA: 0x00057D31 File Offset: 0x00055F31
 private int GetMonsterCount()
 {
     return(TeamComponent.GetTeamMembers(TeamIndex.Monster).Count);
 }
        // Token: 0x06000BF4 RID: 3060 RVA: 0x0003A450 File Offset: 0x00038650
        private void Update()
        {
            if (Time.deltaTime == 0f)
            {
                return;
            }
            if (this.target != this.previousTarget)
            {
                this.previousTarget = this.target;
                Action <CameraRigController, GameObject> action = CameraRigController.onCameraTargetChanged;
                if (action != null)
                {
                    action(this, this.target);
                }
            }
            this.lerpCameraTime   += Time.deltaTime * this.lerpCameraTimeScale;
            this.firstPersonTarget = null;
            float num = this.baseFov;

            this.sceneCam.rect = this.viewport;
            Player      player      = null;
            UserProfile userProfile = null;
            bool        flag        = false;

            if (this.viewer && this.viewer.localUser != null)
            {
                player      = this.viewer.localUser.inputPlayer;
                userProfile = this.viewer.localUser.userProfile;
                flag        = this.viewer.localUser.isUIFocused;
            }
            if (this.cameraMode == CameraRigController.CameraMode.SpectateUser && player != null)
            {
                if (player.GetButtonDown("PrimarySkill"))
                {
                    this.target = CameraRigController.GetNextSpectateGameObject(this.viewer, this.target);
                }
                if (player.GetButtonDown("SecondarySkill"))
                {
                    this.target = CameraRigController.GetPreviousSpectateGameObject(this.viewer, this.target);
                }
            }
            LocalUser     localUserViewer = this.localUserViewer;
            MPEventSystem mpeventSystem   = (localUserViewer != null) ? localUserViewer.eventSystem : null;
            float         num14;
            float         num15;

            if ((!mpeventSystem || !mpeventSystem.isCursorVisible) && player != null && userProfile != null && !flag && this.overrideCam == null)
            {
                float   mouseLookSensitivity = userProfile.mouseLookSensitivity;
                float   num2 = userProfile.stickLookSensitivity * CameraRigController.aimStickGlobalScale.value * 45f;
                Vector2 vector = new Vector2(player.GetAxisRaw(2), player.GetAxisRaw(3));
                Vector2 vector2 = new Vector2(player.GetAxisRaw(16), player.GetAxisRaw(17));
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector.x, userProfile.mouseLookInvertX);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector.y, userProfile.mouseLookInvertY);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector2.x, userProfile.stickLookInvertX);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector2.y, userProfile.stickLookInvertY);
                float magnitude = vector2.magnitude;
                float num3      = magnitude;
                this.aimStickPostSmoothing = Vector2.zero;
                this.aimStickPostDualZone  = Vector2.zero;
                this.aimStickPostExponent  = Vector2.zero;
                if (CameraRigController.aimStickDualZoneSmoothing.value != 0f)
                {
                    float maxDelta = Time.deltaTime / CameraRigController.aimStickDualZoneSmoothing.value;
                    num3 = Mathf.Min(Mathf.MoveTowards(this.stickAimPreviousAcceleratedMagnitude, magnitude, maxDelta), magnitude);
                    this.stickAimPreviousAcceleratedMagnitude = num3;
                    this.aimStickPostSmoothing = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                }
                float num4  = num3;
                float value = CameraRigController.aimStickDualZoneSlope.value;
                float num5;
                if (num4 <= CameraRigController.aimStickDualZoneThreshold.value)
                {
                    num5 = 0f;
                }
                else
                {
                    num5 = 1f - value;
                }
                num3 = value * num4 + num5;
                this.aimStickPostDualZone = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                num3 = Mathf.Pow(num3, CameraRigController.aimStickExponent.value);
                this.aimStickPostExponent = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                if (magnitude != 0f)
                {
                    vector2 *= num3 / magnitude;
                }
                if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic && this.targetBody && !this.targetBody.isSprinting)
                {
                    AimAssistTarget exists     = null;
                    AimAssistTarget exists2    = null;
                    float           value2     = CameraRigController.aimStickAssistMinSize.value;
                    float           num6       = value2 * CameraRigController.aimStickAssistMaxSize.value;
                    float           value3     = CameraRigController.aimStickAssistMaxSlowdownScale.value;
                    float           value4     = CameraRigController.aimStickAssistMinSlowdownScale.value;
                    float           num7       = 0f;
                    float           value5     = 0f;
                    float           num8       = 0f;
                    Vector2         v          = Vector2.zero;
                    Vector2         zero       = Vector2.zero;
                    Vector2         normalized = vector2.normalized;
                    Vector2         vector3    = new Vector2(0.5f, 0.5f);
                    for (int i = 0; i < AimAssistTarget.instancesList.Count; i++)
                    {
                        AimAssistTarget aimAssistTarget = AimAssistTarget.instancesList[i];
                        if (aimAssistTarget.teamComponent.teamIndex != this.targetTeamIndex)
                        {
                            Vector3 vector4 = this.sceneCam.WorldToViewportPoint(aimAssistTarget.point0.position);
                            Vector3 vector5 = this.sceneCam.WorldToViewportPoint(aimAssistTarget.point1.position);
                            float   num9    = Mathf.Lerp(vector4.z, vector5.z, 0.5f);
                            if (num9 > 3f)
                            {
                                float   num10   = 1f / num9;
                                Vector2 vector6 = Util.ClosestPointOnLine(vector4, vector5, vector3) - vector3;
                                float   num11   = Mathf.Clamp01(Util.Remap(vector6.magnitude, value2 * aimAssistTarget.assistScale * num10, num6 * aimAssistTarget.assistScale * num10, 1f, 0f));
                                float   num12   = Mathf.Clamp01(Vector3.Dot(vector6, vector2.normalized));
                                float   num13   = num12 * num11;
                                if (num7 < num11)
                                {
                                    num7    = num11;
                                    exists2 = aimAssistTarget;
                                }
                                if (num13 > num8)
                                {
                                    num7   = num11;
                                    value5 = num12;
                                    exists = aimAssistTarget;
                                    v      = vector6;
                                }
                            }
                        }
                    }
                    Vector2 vector7 = vector2;
                    if (exists2)
                    {
                        float magnitude2 = vector2.magnitude;
                        float d          = Mathf.Clamp01(Util.Remap(1f - num7, 0f, 1f, value3, value4));
                        vector7 *= d;
                    }
                    if (exists)
                    {
                        vector7 = Vector3.RotateTowards(vector7, v, Util.Remap(value5, 1f, 0f, CameraRigController.aimStickAssistMaxDelta.value, CameraRigController.aimStickAssistMinDelta.value), 0f);
                    }
                    vector2 = vector7;
                }
                num14 = vector.x * mouseLookSensitivity * userProfile.mouseLookScaleX + vector2.x * num2 * userProfile.stickLookScaleX * Time.deltaTime;
                num15 = vector.y * mouseLookSensitivity * userProfile.mouseLookScaleY + vector2.y * num2 * userProfile.stickLookScaleY * Time.deltaTime;
            }
            else
            {
                num14 = 0f;
                num15 = 0f;
            }
            NetworkUser         networkUser         = Util.LookUpBodyNetworkUser(this.target);
            NetworkedViewAngles networkedViewAngles = null;

            if (networkUser)
            {
                networkedViewAngles = networkUser.GetComponent <NetworkedViewAngles>();
            }
            this.targetTeamIndex = TeamIndex.None;
            bool flag2 = false;

            if (this.target)
            {
                this.targetBody = this.target.GetComponent <CharacterBody>();
                flag2           = this.targetBody.isSprinting;
                TeamComponent component = this.target.GetComponent <TeamComponent>();
                if (component)
                {
                    this.targetTeamIndex = component.teamIndex;
                }
                this.targetParams = this.target.GetComponent <CameraTargetParams>();
            }
            Vector3 vector8 = this.desiredCameraState.position;

            if (this.targetParams)
            {
                Vector3 position            = this.target.transform.position;
                Vector3 cameraPivotPosition = this.targetParams.cameraPivotPosition;
                if (this.targetParams.dontRaycastToPivot)
                {
                    vector8 = cameraPivotPosition;
                }
                else
                {
                    Vector3 direction = cameraPivotPosition - position;
                    Ray     ray       = new Ray(position, direction);
                    float   distance  = this.Raycast(ray, direction.magnitude, this.targetParams.cameraParams.wallCushion);
                    vector8 = ray.GetPoint(distance);
                }
            }
            if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic || this.cameraMode == CameraRigController.CameraMode.SpectateUser)
            {
                float   min = -89.9f;
                float   max = 89.9f;
                Vector3 idealLocalCameraPos = new Vector3(0f, 0f, 0f);
                float   wallCushion         = 0.1f;
                Vector2 vector9             = Vector2.zero;
                if (this.targetParams)
                {
                    min = this.targetParams.cameraParams.minPitch;
                    max = this.targetParams.cameraParams.maxPitch;
                    idealLocalCameraPos = this.targetParams.idealLocalCameraPos;
                    wallCushion         = this.targetParams.cameraParams.wallCushion;
                    vector9             = this.targetParams.recoil;
                    if (this.targetParams.aimMode == CameraTargetParams.AimType.FirstPerson)
                    {
                        this.firstPersonTarget = this.target;
                    }
                    if (this.targetParams.fovOverride >= 0f)
                    {
                        num    = this.targetParams.fovOverride;
                        num14 *= num / this.baseFov;
                        num15 *= num / this.baseFov;
                    }
                    if (this.targetBody && flag2)
                    {
                        num14 *= 0.5f;
                        num15 *= 0.5f;
                    }
                }
                if (this.sprintingParticleSystem)
                {
                    ParticleSystem.MainModule main = this.sprintingParticleSystem.main;
                    if (flag2)
                    {
                        main.loop = true;
                        if (!this.sprintingParticleSystem.isPlaying)
                        {
                            this.sprintingParticleSystem.Play();
                        }
                    }
                    else
                    {
                        main.loop = false;
                    }
                }
                if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic)
                {
                    float num16 = this.pitch - num15;
                    float num17 = this.yaw + num14;
                    num16     += vector9.y;
                    num17     += vector9.x;
                    this.pitch = Mathf.Clamp(num16, min, max);
                    this.yaw   = Mathf.Repeat(num17, 360f);
                }
                else if (this.cameraMode == CameraRigController.CameraMode.SpectateUser && this.target)
                {
                    if (networkedViewAngles)
                    {
                        this.SetPitchYaw(networkedViewAngles.viewAngles);
                    }
                    else
                    {
                        InputBankTest component2 = this.target.GetComponent <InputBankTest>();
                        if (component2)
                        {
                            this.SetPitchYawFromLookVector(component2.aimDirection);
                        }
                    }
                }
                this.desiredCameraState.rotation = Quaternion.Euler(this.pitch, this.yaw, 0f);
                Vector3 direction2 = vector8 + this.desiredCameraState.rotation * idealLocalCameraPos - vector8;
                float   num18      = direction2.magnitude;
                float   num19      = (1f + this.pitch / -90f) * 0.5f;
                num18 *= Mathf.Sqrt(1f - num19);
                if (num18 < 0.25f)
                {
                    num18 = 0.25f;
                }
                float a = this.Raycast(new Ray(vector8, direction2), num18, wallCushion);
                this.currentCameraDistance       = Mathf.Min(a, Mathf.SmoothDamp(this.currentCameraDistance, a, ref this.cameraDistanceVelocity, 0.5f));
                this.desiredCameraState.position = vector8 + direction2.normalized * this.currentCameraDistance;
                this.pitch -= vector9.y;
                this.yaw   -= vector9.x;
                if (networkedViewAngles && networkedViewAngles.hasEffectiveAuthority)
                {
                    networkedViewAngles.viewAngles = new PitchYawPair(this.pitch, this.yaw);
                }
            }
            if (this.targetBody)
            {
                num *= (this.targetBody.isSprinting ? 1.3f : 1f);
            }
            this.desiredCameraState.fov = Mathf.SmoothDamp(this.desiredCameraState.fov, num, ref this.fovVelocity, 0.2f, float.PositiveInfinity, Time.deltaTime);
            if (this.hud)
            {
                CharacterMaster targetMaster = this.targetBody ? this.targetBody.master : null;
                this.hud.targetMaster = targetMaster;
            }
            this.UpdateCrosshair(vector8);
            CameraState cameraState = this.desiredCameraState;

            if (this.overrideCam != null)
            {
                if ((UnityEngine.Object) this.overrideCam)
                {
                    cameraState = this.overrideCam.GetCameraState(this);
                }
                this.overrideCam = null;
            }
            if (this.lerpCameraTime >= 1f)
            {
                this.currentCameraState = cameraState;
            }
            else
            {
                this.currentCameraState = CameraState.Lerp(ref this.lerpCameraState, ref cameraState, CameraRigController.RemapLerpTime(this.lerpCameraTime));
            }
            this.SetCameraState(this.currentCameraState);
        }
        private void AddDot(GameObject attackerObject, float duration, DotController.DotIndex dotIndex, float damageMultiplier)
        {
            if (!NetworkServer.active)
            {
                Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::AddDot(UnityEngine.GameObject,System.Single,RoR2.DotController/DotIndex,System.Single)' called on client");
                return;
            }
            if (dotIndex < DotController.DotIndex.Bleed || dotIndex >= DotController.DotIndex.Count)
            {
                return;
            }
            TeamIndex     teamIndex = TeamIndex.Neutral;
            float         num       = 0f;
            TeamComponent component = attackerObject.GetComponent <TeamComponent>();

            if (component)
            {
                teamIndex = component.teamIndex;
            }
            CharacterBody component2 = attackerObject.GetComponent <CharacterBody>();

            if (component2)
            {
                num = component2.damage;
            }
            DotController.DotDef   dotDef   = DotController.dotDefs[(int)dotIndex];
            DotController.DotStack dotStack = new DotController.DotStack
            {
                dotIndex       = dotIndex,
                dotDef         = dotDef,
                attackerObject = attackerObject,
                attackerTeam   = teamIndex,
                timer          = duration,
                damage         = dotDef.damageCoefficient * num * damageMultiplier,
                damageType     = DamageType.Generic
            };
            switch (dotIndex)
            {
            case DotController.DotIndex.Helfire:
            {
                if (!component2)
                {
                    return;
                }
                HealthComponent healthComponent = component2.healthComponent;
                if (!healthComponent)
                {
                    return;
                }
                dotStack.damage = healthComponent.fullHealth * 0.01f * damageMultiplier;
                if (this.victimObject == attackerObject)
                {
                    dotStack.damageType |= (DamageType.NonLethal | DamageType.Silent);
                }
                else if (this.victimTeam == teamIndex)
                {
                    dotStack.damage *= 0.5f;
                }
                else
                {
                    dotStack.damage *= 24f;
                }
                int i     = 0;
                int count = this.dotStackList.Count;
                while (i < count)
                {
                    if (this.dotStackList[i].dotIndex == DotController.DotIndex.Helfire && this.dotStackList[i].attackerObject == attackerObject)
                    {
                        this.dotStackList[i].timer  = Mathf.Max(this.dotStackList[i].timer, duration);
                        this.dotStackList[i].damage = dotStack.damage;
                        return;
                    }
                    i++;
                }
                if (this.victimBody)
                {
                    EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/HelfireIgniteEffect"), new EffectData
                        {
                            origin = this.victimBody.corePosition
                        }, true);
                }
                break;
            }

            case DotController.DotIndex.PercentBurn:
                dotStack.damage = Mathf.Min(dotStack.damage, this.victimBody.healthComponent.fullCombinedHealth * 0.01f);
                break;

            case DotController.DotIndex.Poison:
            {
                float a = this.victimHealthComponent.fullCombinedHealth / 100f * 1f * dotDef.interval;
                dotStack.damage     = Mathf.Min(Mathf.Max(a, dotStack.damage), dotStack.damage * 50f);
                dotStack.damageType = DamageType.NonLethal;
                int j      = 0;
                int count2 = this.dotStackList.Count;
                while (j < count2)
                {
                    if (this.dotStackList[j].dotIndex == DotController.DotIndex.Poison)
                    {
                        this.dotStackList[j].timer  = Mathf.Max(this.dotStackList[j].timer, duration);
                        this.dotStackList[j].damage = dotStack.damage;
                        return;
                    }
                    j++;
                }
                bool flag = false;
                for (int k = 0; k < this.dotStackList.Count; k++)
                {
                    if (this.dotStackList[k].dotIndex == DotController.DotIndex.Poison)
                    {
                        flag = true;
                        break;
                    }
                }
                if (!flag && component2 != null)
                {
                    CharacterMaster master = component2.master;
                    if (master != null)
                    {
                        PlayerStatsComponent playerStatsComponent = master.playerStatsComponent;
                        if (playerStatsComponent != null)
                        {
                            playerStatsComponent.currentStats.PushStatValue(StatDef.totalCrocoInfectionsInflicted, 1UL);
                        }
                    }
                }
                break;
            }
            }
            this.dotStackList.Add(dotStack);
            this.OnDotStackAddedServer(dotStack);
        }
        // Token: 0x060017BB RID: 6075 RVA: 0x00066F64 File Offset: 0x00065164
        public CharacterMaster Perform()
        {
            TeamIndex teamIndex;

            if (this.teamIndexOverride != null)
            {
                teamIndex = this.teamIndexOverride.Value;
            }
            else
            {
                if (!this.summonerBodyObject)
                {
                    Debug.LogErrorFormat("Cannot spawn master {0}: No team specified.", new object[]
                    {
                        this.masterPrefab
                    });
                    return(null);
                }
                teamIndex = TeamComponent.GetObjectTeam(this.summonerBodyObject);
            }
            if (!this.ignoreTeamMemberLimit)
            {
                TeamDef teamDef = TeamCatalog.GetTeamDef(teamIndex);
                if (teamDef == null)
                {
                    Debug.LogErrorFormat("Attempting to spawn master {0} on TeamIndex.None. Is this intentional?", new object[]
                    {
                        this.masterPrefab
                    });
                    return(null);
                }
                if (teamDef != null && teamDef.softCharacterLimit <= TeamComponent.GetTeamMembers(teamIndex).Count)
                {
                    return(null);
                }
            }
            CharacterBody   characterBody   = null;
            CharacterMaster characterMaster = null;

            if (this.summonerBodyObject)
            {
                characterBody = this.summonerBodyObject.GetComponent <CharacterBody>();
            }
            if (characterBody)
            {
                characterMaster = characterBody.master;
            }
            GameObject      gameObject = UnityEngine.Object.Instantiate <GameObject>(this.masterPrefab, this.position, this.rotation);
            CharacterMaster component  = gameObject.GetComponent <CharacterMaster>();

            component.teamIndex = teamIndex;
            if (this.loadout != null)
            {
                component.SetLoadoutServer(this.loadout);
            }
            CharacterMaster characterMaster2 = characterMaster;

            if (characterMaster2 && characterMaster2.minionOwnership.ownerMaster)
            {
                characterMaster2 = characterMaster2.minionOwnership.ownerMaster;
            }
            component.minionOwnership.SetOwner(characterMaster2);
            if (this.summonerBodyObject)
            {
                AIOwnership component2 = gameObject.GetComponent <AIOwnership>();
                if (component2)
                {
                    if (characterMaster)
                    {
                        component2.ownerMaster = characterMaster;
                    }
                    CharacterBody component3 = this.summonerBodyObject.GetComponent <CharacterBody>();
                    if (component3)
                    {
                        CharacterMaster master = component3.master;
                        if (master)
                        {
                            component2.ownerMaster = master;
                        }
                    }
                }
                BaseAI component4 = gameObject.GetComponent <BaseAI>();
                if (component4)
                {
                    component4.leader.gameObject = this.summonerBodyObject;
                }
            }
            Action <CharacterMaster> action = this.preSpawnSetupCallback;

            if (action != null)
            {
                action(component);
            }
            NetworkServer.Spawn(gameObject);
            component.Respawn(this.position, this.rotation, false);
            return(component);
        }