// Token: 0x06000A22 RID: 2594 RVA: 0x0002C30F File Offset: 0x0002A50F
 private void OnDisable()
 {
     if (DirectorCore.instance == this)
     {
         DirectorCore.instance = null;
     }
 }
        // Token: 0x06000F8A RID: 3978 RVA: 0x00044464 File Offset: 0x00042664
        private static void OnSceneDirectorPrePopulateSceneServer(SceneDirector sceneDirector)
        {
            DirectorCore instance        = DirectorCore.instance;
            NodeGraph    groundNodeGraph = SceneInfo.instance.GetNodeGraph(MapNodeGroup.GraphType.Ground);

            foreach (NodeGraph.NodeIndex nodeIndex in OccupyNearbyNodes.instancesList.SelectMany((OccupyNearbyNodes v) => groundNodeGraph.FindNodesInRange(v.transform.position, 0f, v.radius, HullMask.None)).Distinct <NodeGraph.NodeIndex>().ToArray <NodeGraph.NodeIndex>())
            {
                instance.AddOccupiedNode(groundNodeGraph, nodeIndex);
            }
        }
 // Token: 0x06000A21 RID: 2593 RVA: 0x0002C2DB File Offset: 0x0002A4DB
 private void OnEnable()
 {
     if (!DirectorCore.instance)
     {
         DirectorCore.instance = this;
         return;
     }
     Debug.LogErrorFormat(this, "Duplicate instance of singleton class {0}. Only one should exist at a time.", new object[]
     {
         base.GetType().Name
     });
 }
예제 #4
0
        public bool AlternateSpawnBehavior(GameObject spawnTarget, bool canBeElite)
        {
            if (this.currentMonsterCard.CardIsValid() && this.monsterCredit >= (float)this.currentMonsterCard.cost)
            {
                SpawnCard             spawnCard             = this.currentMonsterCard.spawnCard;
                DirectorPlacementRule directorPlacementRule = new DirectorPlacementRule
                {
                    placementMode   = DirectorPlacementRule.PlacementMode.Approximate,
                    spawnOnTarget   = spawnTarget.transform,
                    preventOverhead = this.currentMonsterCard.preventOverhead
                };
                DirectorCore.GetMonsterSpawnDistance(this.currentMonsterCard.spawnDistance, out directorPlacementRule.minDistance, out directorPlacementRule.maxDistance);
                directorPlacementRule.minDistance *= this.spawnDistanceMultiplier;
                directorPlacementRule.maxDistance *= this.spawnDistanceMultiplier;
                GameObject gameObject = DirectorCore.instance.TrySpawnObject(spawnCard, directorPlacementRule, this.rng);
                if (gameObject)
                {
                    int             cost          = this.currentMonsterCard.cost;
                    float           num3          = 1f;
                    float           num4          = 1f;
                    CharacterMaster component     = gameObject.GetComponent <CharacterMaster>();
                    GameObject      bodyObject    = component.GetBodyObject();
                    CharacterBody   characterBody = bodyObject.GetComponent <CharacterBody>();
                    if (this.isBoss)
                    {
                        if (!this.bossGroup)
                        {
                            GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/BossGroup"));
                            NetworkServer.Spawn(gameObject2);
                            this.bossGroup = gameObject2.GetComponent <BossGroup>();
                            this.bossGroup.dropPosition = this.dropPosition;
                        }
                        this.bossGroup.AddMember(component);
                    }
                    // assumes CombatDirector.maximumNumberToSpawnBeforeSkipping == 4f; maybe add a check for this?
                    if (canBeElite) //try to make the mob elite before adding bonus items
                    {
                        if ((float)cost * CombatDirector.eliteMultiplierCost <= this.monsterCredit)
                        {
                            num3 = 4.7f;
                            num4 = 2f;
                            component.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(this.currentActiveEliteIndex).eliteEquipmentIndex);
                            cost = (int)((float)cost * CombatDirector.eliteMultiplierCost);

                            //This is where we add the bonus items
                            var minCost = ((int)this.monsterCredit) / 4;  //CombatDirector.maximumNumberToSpawnBeforeSkipping
                            while (cost < minCost)
                            {
                                var newItem   = BalanceMod.Hooks.mobItemSelection.Evaluate(this.rng.nextNormalizedFloat);
                                var itemIndex = newItem.itemIndex;
                                var itemCount = newItem.itemCount;
                                // Debug.Log($"Giving {itemCount} of item {itemIndex}");
                                if (BalanceMod.Hooks.PatchLateGameMonsterSpawns_EnemyItemsInChat)
                                {
                                    Chat.AddPickupMessage(characterBody, ItemCatalog.GetItemDef(itemIndex).nameToken, BalanceMod.Hooks.GetItemColor(itemIndex), (uint)itemCount);
                                }
                                component.inventory.GiveItem(itemIndex, itemCount);
                                cost *= 2;
                            }
                        }
                    }
                    else
                    {                                                //This is where we add the bonus items
                        var minCost = ((int)this.monsterCredit) / 4; //CombatDirector.maximumNumberToSpawnBeforeSkipping
                        while (cost < minCost)
                        {
                            var newItem   = BalanceMod.Hooks.mobItemSelection.Evaluate(this.rng.nextNormalizedFloat);
                            var itemIndex = newItem.itemIndex;
                            var itemCount = newItem.itemCount;
                            // Debug.Log($"Giving {itemCount} of item {itemIndex}");
                            if (BalanceMod.Hooks.PatchLateGameMonsterSpawns_EnemyItemsInChat)
                            {
                                Chat.AddPickupMessage(characterBody, ItemCatalog.GetItemDef(itemIndex).nameToken, BalanceMod.Hooks.GetItemColor(itemIndex), (uint)itemCount);
                            }
                            component.inventory.GiveItem(itemIndex, itemCount);
                            cost *= 2;
                        }
                    }
                    this.monsterCredit -= (float)cost;
                    if (this.isBoss)
                    {
                        int livingPlayerCount = Run.instance.livingPlayerCount;
                        num3 *= Mathf.Pow((float)livingPlayerCount, 1f);
                    }
                    //elites have +400% hp and +100% damage
                    component.inventory.GiveItem(ItemIndex.BoostHp, Mathf.RoundToInt((num3 - 1f) * 10f));
                    component.inventory.GiveItem(ItemIndex.BoostDamage, Mathf.RoundToInt((num4 - 1f) * 10f));
                    DeathRewards component2 = bodyObject.GetComponent <DeathRewards>();
                    if (component2)
                    {
                        component2.expReward  = (uint)((float)cost * this.expRewardCoefficient * Run.instance.compensatedDifficultyCoefficient);
                        component2.goldReward = (uint)((float)cost * this.expRewardCoefficient * 2f * Run.instance.compensatedDifficultyCoefficient);
                    }
                    if (this.spawnEffectPrefab && NetworkServer.active)
                    {
                        Vector3 origin = gameObject.transform.position;
                        if (characterBody)
                        {
                            origin = characterBody.corePosition;
                        }
                        EffectManager.instance.SpawnEffect(this.spawnEffectPrefab, new EffectData
                        {
                            origin = origin
                        }, true);
                    }
                    return(true);
                }
            }
            return(false);
        }
예제 #5
0
 // Token: 0x06000DBF RID: 3519 RVA: 0x00043984 File Offset: 0x00041B84
 private bool AttemptSpawnOnTarget(GameObject spawnTarget)
 {
     if (spawnTarget)
     {
         if (this.currentMonsterCard == null)
         {
             this.currentMonsterCard       = this.monsterCards.Evaluate(this.rng.nextNormalizedFloat);
             this.lastAttemptedMonsterCard = this.currentMonsterCard;
             this.currentActiveEliteIndex  = EliteCatalog.eliteList[this.rng.RangeInt(0, EliteCatalog.eliteList.Count)];
         }
         bool  flag = !(this.currentMonsterCard.spawnCard as CharacterSpawnCard).noElites;
         float num  = CombatDirector.maximumNumberToSpawnBeforeSkipping * (flag ? CombatDirector.eliteMultiplierCost : 1f);
         if (this.currentMonsterCard.CardIsValid() && this.monsterCredit >= (float)this.currentMonsterCard.cost && (!this.skipSpawnIfTooCheap || this.monsterCredit <= (float)this.currentMonsterCard.cost * num))
         {
             SpawnCard             spawnCard             = this.currentMonsterCard.spawnCard;
             DirectorPlacementRule directorPlacementRule = new DirectorPlacementRule
             {
                 placementMode   = DirectorPlacementRule.PlacementMode.Approximate,
                 spawnOnTarget   = spawnTarget.transform,
                 preventOverhead = this.currentMonsterCard.preventOverhead
             };
             DirectorCore.GetMonsterSpawnDistance(this.currentMonsterCard.spawnDistance, out directorPlacementRule.minDistance, out directorPlacementRule.maxDistance);
             directorPlacementRule.minDistance *= this.spawnDistanceMultiplier;
             directorPlacementRule.maxDistance *= this.spawnDistanceMultiplier;
             GameObject gameObject = DirectorCore.instance.TrySpawnObject(spawnCard, directorPlacementRule, this.rng);
             if (gameObject)
             {
                 int             num2       = this.currentMonsterCard.cost;
                 float           num3       = 1f;
                 float           num4       = 1f;
                 CharacterMaster component  = gameObject.GetComponent <CharacterMaster>();
                 GameObject      bodyObject = component.GetBodyObject();
                 if (this.isBoss)
                 {
                     if (!this.bossGroup)
                     {
                         GameObject gameObject2 = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/BossGroup"));
                         NetworkServer.Spawn(gameObject2);
                         this.bossGroup = gameObject2.GetComponent <BossGroup>();
                         this.bossGroup.dropPosition = this.dropPosition;
                     }
                     this.bossGroup.AddMember(component);
                 }
                 if (flag && (float)num2 * CombatDirector.eliteMultiplierCost <= this.monsterCredit)
                 {
                     num3 = 4.7f;
                     num4 = 2f;
                     component.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(this.currentActiveEliteIndex).eliteEquipmentIndex);
                     num2 = (int)((float)num2 * CombatDirector.eliteMultiplierCost);
                 }
                 int num5 = num2;
                 this.monsterCredit -= (float)num5;
                 if (this.isBoss)
                 {
                     int livingPlayerCount = Run.instance.livingPlayerCount;
                     num3 *= Mathf.Pow((float)livingPlayerCount, 1f);
                 }
                 component.inventory.GiveItem(ItemIndex.BoostHp, Mathf.RoundToInt((num3 - 1f) * 10f));
                 component.inventory.GiveItem(ItemIndex.BoostDamage, Mathf.RoundToInt((num4 - 1f) * 10f));
                 DeathRewards component2 = bodyObject.GetComponent <DeathRewards>();
                 if (component2)
                 {
                     component2.expReward  = (uint)((float)num2 * this.expRewardCoefficient * Run.instance.compensatedDifficultyCoefficient);
                     component2.goldReward = (uint)((float)num2 * this.expRewardCoefficient * 2f * Run.instance.compensatedDifficultyCoefficient);
                 }
                 if (this.spawnEffectPrefab && NetworkServer.active)
                 {
                     Vector3       origin     = gameObject.transform.position;
                     CharacterBody component3 = bodyObject.GetComponent <CharacterBody>();
                     if (component3)
                     {
                         origin = component3.corePosition;
                     }
                     EffectManager.instance.SpawnEffect(this.spawnEffectPrefab, new EffectData
                     {
                         origin = origin
                     }, true);
                 }
                 return(true);
             }
         }
     }
     return(false);
 }
        // Token: 0x06000934 RID: 2356 RVA: 0x00027E88 File Offset: 0x00026088
        private bool AttemptSpawnOnTarget(GameObject spawnTarget)
        {
            if (this.currentMonsterCard == null)
            {
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.Log("Current monster card is null, pick new one.");
                }
                this.PrepareNewMonsterWave(this.monsterCards.Evaluate(this.rng.nextNormalizedFloat));
            }
            if (!spawnTarget)
            {
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.LogFormat("Spawn target {0} is invalid.", new object[]
                    {
                        spawnTarget
                    });
                }
                return(false);
            }
            if (this.spawnCountInCurrentWave >= this.maximumNumberToSpawnBeforeSkipping)
            {
                this.spawnCountInCurrentWave = 0;
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.LogFormat("Spawn count has hit the max ({0}/{1}). Aborting spawn.", new object[]
                    {
                        this.spawnCountInCurrentWave,
                        this.maximumNumberToSpawnBeforeSkipping
                    });
                }
                return(false);
            }
            int cost = this.currentMonsterCard.cost;
            int num  = this.currentMonsterCard.cost;
            int num2 = this.currentMonsterCard.cost;

            CombatDirector.EliteTierDef eliteTierDef = this.currentActiveEliteTier;
            EliteIndex eliteIndex = this.currentActiveEliteIndex;

            num2 = (int)((float)num * this.currentActiveEliteTier.costMultiplier);
            if ((float)num2 <= this.monsterCredit)
            {
                num          = num2;
                eliteTierDef = this.currentActiveEliteTier;
                eliteIndex   = this.currentActiveEliteIndex;
            }
            else
            {
                eliteTierDef = CombatDirector.eliteTiers[0];
                eliteIndex   = EliteIndex.None;
            }
            if (!this.currentMonsterCard.CardIsValid())
            {
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.LogFormat("Spawn card {0} is invalid, aborting spawn.", new object[]
                    {
                        this.currentMonsterCard.spawnCard
                    });
                }
                return(false);
            }
            if (this.monsterCredit < (float)num)
            {
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.LogFormat("Spawn card {0} is too expensive, aborting spawn.", new object[]
                    {
                        this.currentMonsterCard.spawnCard
                    });
                }
                return(false);
            }
            if (this.skipSpawnIfTooCheap && (float)(num2 * this.maximumNumberToSpawnBeforeSkipping) < this.monsterCredit)
            {
                if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                {
                    Debug.LogFormat("Card {0} seems too cheap ({1}/{2}). Comparing against most expensive possible ({3})", new object[]
                    {
                        this.currentMonsterCard.spawnCard,
                        num * this.maximumNumberToSpawnBeforeSkipping,
                        this.monsterCredit,
                        this.mostExpensiveMonsterCostInDeck
                    });
                }
                if (this.mostExpensiveMonsterCostInDeck > num)
                {
                    if (CombatDirector.cvDirectorCombatEnableInternalLogs.value)
                    {
                        Debug.LogFormat("Spawn card {0} is too cheap, aborting spawn.", new object[]
                        {
                            this.currentMonsterCard.spawnCard
                        });
                    }
                    return(false);
                }
            }
            SpawnCard             spawnCard             = this.currentMonsterCard.spawnCard;
            DirectorPlacementRule directorPlacementRule = new DirectorPlacementRule
            {
                placementMode   = DirectorPlacementRule.PlacementMode.Approximate,
                spawnOnTarget   = spawnTarget.transform,
                preventOverhead = this.currentMonsterCard.preventOverhead
            };

            DirectorCore.GetMonsterSpawnDistance(this.currentMonsterCard.spawnDistance, out directorPlacementRule.minDistance, out directorPlacementRule.maxDistance);
            directorPlacementRule.minDistance *= this.spawnDistanceMultiplier;
            directorPlacementRule.maxDistance *= this.spawnDistanceMultiplier;
            DirectorSpawnRequest directorSpawnRequest = new DirectorSpawnRequest(spawnCard, directorPlacementRule, this.rng);

            directorSpawnRequest.ignoreTeamMemberLimit = true;
            directorSpawnRequest.teamIndexOverride     = new TeamIndex?(TeamIndex.Monster);
            GameObject gameObject = DirectorCore.instance.TrySpawnObject(directorSpawnRequest);

            if (!gameObject)
            {
                Debug.LogFormat("Spawn card {0} failed to spawn. Aborting cost procedures.", new object[]
                {
                    spawnCard
                });
                return(false);
            }
            this.monsterCredit -= (float)num;
            this.spawnCountInCurrentWave++;
            CharacterMaster component  = gameObject.GetComponent <CharacterMaster>();
            GameObject      bodyObject = component.GetBodyObject();

            if (this.combatSquad)
            {
                this.combatSquad.AddMember(component);
            }
            float          num3 = eliteTierDef.healthBoostCoefficient;
            float          damageBoostCoefficient = eliteTierDef.damageBoostCoefficient;
            EliteDef       eliteDef       = EliteCatalog.GetEliteDef(eliteIndex);
            EquipmentIndex equipmentIndex = (eliteDef != null) ? eliteDef.eliteEquipmentIndex : EquipmentIndex.None;

            if (equipmentIndex != EquipmentIndex.None)
            {
                component.inventory.SetEquipmentIndex(equipmentIndex);
            }
            if (this.combatSquad)
            {
                int livingPlayerCount = Run.instance.livingPlayerCount;
                num3 *= Mathf.Pow((float)livingPlayerCount, 1f);
            }
            component.inventory.GiveItem(ItemIndex.BoostHp, Mathf.RoundToInt((num3 - 1f) * 10f));
            component.inventory.GiveItem(ItemIndex.BoostDamage, Mathf.RoundToInt((damageBoostCoefficient - 1f) * 10f));
            DeathRewards component2 = bodyObject.GetComponent <DeathRewards>();

            if (component2)
            {
                component2.expReward  = (uint)((float)num * this.expRewardCoefficient * Run.instance.compensatedDifficultyCoefficient);
                component2.goldReward = (uint)((float)num * this.expRewardCoefficient * 2f * Run.instance.compensatedDifficultyCoefficient);
            }
            if (this.spawnEffectPrefab && NetworkServer.active)
            {
                Vector3       origin     = gameObject.transform.position;
                CharacterBody component3 = bodyObject.GetComponent <CharacterBody>();
                if (component3)
                {
                    origin = component3.corePosition;
                }
                EffectManager.SpawnEffect(this.spawnEffectPrefab, new EffectData
                {
                    origin = origin
                }, true);
            }
            CombatDirector.OnSpawnedServer onSpawnedServer = this.onSpawnedServer;
            if (onSpawnedServer != null)
            {
                onSpawnedServer.Invoke(gameObject);
            }
            return(true);
        }