Example #1
0
 // Token: 0x06000B4B RID: 2891 RVA: 0x00031D04 File Offset: 0x0002FF04
 private void OnTriggerStay(Collider other)
 {
     if (NetworkServer.active && this.waitStartTime.timeSince >= this.waitDuration && !this.consumed)
     {
         CharacterBody component = other.GetComponent <CharacterBody>();
         if (component)
         {
             ItemIndex itemIndex = this.pickupIndex.itemIndex;
             if (itemIndex != ItemIndex.None && ItemCatalog.GetItemDef(itemIndex).tier == ItemTier.Lunar)
             {
                 return;
             }
             EquipmentIndex equipmentIndex = this.pickupIndex.equipmentIndex;
             if (equipmentIndex != EquipmentIndex.None)
             {
                 if (EquipmentCatalog.GetEquipmentDef(equipmentIndex).isLunar)
                 {
                     return;
                 }
                 if (component.inventory && component.inventory.currentEquipmentIndex != EquipmentIndex.None)
                 {
                     return;
                 }
             }
             if (this.pickupIndex.coinValue != 0U)
             {
                 return;
             }
             if (GenericPickupController.BodyHasPickupPermission(component))
             {
                 this.AttemptGrant(component);
             }
         }
     }
 }
        private static void Init()
        {
            List <ItemIndex>      list      = new List <ItemIndex>();
            List <EquipmentIndex> list2     = new List <EquipmentIndex>();
            ItemIndex             itemIndex = ItemIndex.Syringe;
            ItemIndex             itemCount = (ItemIndex)ItemCatalog.itemCount;

            while (itemIndex < itemCount)
            {
                ItemDef itemDef = ItemCatalog.GetItemDef(itemIndex);
                if (itemDef.tier == ItemTier.Lunar || itemDef.ContainsTag(ItemTag.Cleansable))
                {
                    list.Add(itemIndex);
                }
                itemIndex++;
            }
            EquipmentIndex equipmentIndex = EquipmentIndex.CommandMissile;
            EquipmentIndex equipmentCount = (EquipmentIndex)EquipmentCatalog.equipmentCount;

            while (equipmentIndex < equipmentCount)
            {
                if (EquipmentCatalog.GetEquipmentDef(equipmentIndex).isLunar)
                {
                    list2.Add(equipmentIndex);
                }
                equipmentIndex++;
            }
            ShrineCleanseBehavior.cleansableItems      = list.ToArray();
            ShrineCleanseBehavior.cleansableEquipments = list2.ToArray();
        }
        private void Execute()
        {
            if (!NetworkServer.active)
            {
                Debug.LogWarning("[Server] function 'System.Void RoR2.EquipmentSlot::Execute()' called on client");
                return;
            }
            EquipmentIndex equipmentIndex = this.equipmentIndex;

            if (EquipmentCatalog.GetEquipmentDef(equipmentIndex) != null && this.subcooldownTimer <= 0f && this.PerformEquipmentAction(equipmentIndex))
            {
                this.inventory.DeductEquipmentCharges(this.activeEquipmentSlot, 1);
                this.UpdateInventory();
                this.CallRpcOnClientEquipmentActivationRecieved();
                Action <EquipmentSlot, EquipmentIndex> action = EquipmentSlot.onServerEquipmentActivated;
                if (action != null)
                {
                    action(this, equipmentIndex);
                }
                if (this.characterBody && this.inventory)
                {
                    int itemCount = this.inventory.GetItemCount(ItemIndex.EnergizedOnEquipmentUse);
                    if (itemCount > 0)
                    {
                        this.characterBody.AddTimedBuff(BuffIndex.Energized, (float)(8 + 4 * (itemCount - 1)));
                    }
                }
            }
        }
Example #4
0
        // no use because its tied to UserProfile and nothing else

        /*public bool isValid
         * {
         *  get
         *  {
         *      return value < TotalItemCount + TotalEquipmentCount + CoinCount;
         *  }
         * }*/

        public GameObject GetPickupDisplayPrefab()
        {
            // Check if the custom item has a custom prefab.

            var currentCustomItem = ItemLib.ItemLib.GetCustomItem(value);

            if (currentCustomItem != null && currentCustomItem.Prefab != null)
            {
                return(currentCustomItem.Prefab);
            }

            var currentCustomEquipment = ItemLib.ItemLib.GetCustomEquipment(value);

            if (currentCustomEquipment != null && currentCustomEquipment.Prefab != null)
            {
                return(currentCustomEquipment.Prefab);
            }

            if (value >= 0)
            {
                if (value < TotalItemCount)
                {
                    return(Resources.Load <GameObject>(ItemCatalog.GetItemDef((ItemIndex)value).pickupModelPath));
                }
                if (value < TotalItemCount + TotalEquipmentCount)
                {
                    return(Resources.Load <GameObject>(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(value - TotalItemCount)).pickupModelPath));
                }
                if (value < TotalItemCount + TotalEquipmentCount + CoinCount)
                {
                    return(Resources.Load <GameObject>("Prefabs/PickupModels/PickupLunarCoin"));
                }
            }
            return(null);
        }
 // Token: 0x06000D88 RID: 3464 RVA: 0x0003CD18 File Offset: 0x0003AF18
 public EquipmentState(EquipmentIndex equipmentIndex, Run.FixedTimeStamp chargeFinishTime, byte charges)
 {
     this.equipmentIndex   = equipmentIndex;
     this.chargeFinishTime = chargeFinishTime;
     this.charges          = charges;
     this.dirty            = true;
     this.equipmentDef     = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
 }
 // Token: 0x06000577 RID: 1399 RVA: 0x000161DB File Offset: 0x000143DB
 public void AddEquipment(EquipmentIndex equipmentIndex)
 {
     if (!EquipmentCatalog.IsIndexValid(equipmentIndex))
     {
         return;
     }
     this.a |= 1UL << (int)equipmentIndex;
 }
 // Token: 0x06000578 RID: 1400 RVA: 0x000161FB File Offset: 0x000143FB
 public void RemoveEquipment(EquipmentIndex equipmentIndex)
 {
     if (!EquipmentCatalog.IsIndexValid(equipmentIndex))
     {
         return;
     }
     this.a &= ~(1UL << (int)equipmentIndex);
 }
 public void GiveEquipmentString(string equipmentString)
 {
     if (!NetworkServer.active)
     {
         Debug.LogWarning("[Server] function 'System.Void RoR2.Inventory::GiveEquipmentString(System.String)' called on client");
         return;
     }
     this.SetEquipmentIndex(EquipmentCatalog.FindEquipmentIndex(equipmentString));
 }
Example #9
0
 // Token: 0x0600192B RID: 6443 RVA: 0x00078E90 File Offset: 0x00077090
 public bool IsBoss()
 {
     if (this.value >= 0)
     {
         if (this.value < 78)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)this.value).tier == ItemTier.Boss);
         }
         if (this.value < 105)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(this.value - 78)).isBoss);
         }
     }
     return(false);
 }
Example #10
0
 // Token: 0x06001929 RID: 6441 RVA: 0x00078DE8 File Offset: 0x00076FE8
 public string GetUnlockableName()
 {
     if (this.value >= 0)
     {
         if (this.value < 78)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)this.value).unlockableName);
         }
         if (this.value < 105)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(this.value - 78)).unlockableName);
         }
     }
     return("");
 }
Example #11
0
 // Token: 0x0600056E RID: 1390 RVA: 0x0001610C File Offset: 0x0001430C
 public static EliteIndex GetEquipmentEliteIndex(EquipmentIndex equipmentIndex)
 {
     if (!EquipmentCatalog.IsIndexValid(equipmentIndex))
     {
         return(EliteIndex.None);
     }
     foreach (EliteDef eliteDef in EliteCatalog.eliteDefs)
     {
         if (eliteDef.eliteEquipmentIndex == equipmentIndex)
         {
             return(eliteDef.eliteIndex);
         }
     }
     return(EliteIndex.None);
 }
Example #12
0
 public string GetUnlockableName()
 {
     if (value >= 0)
     {
         if (value < TotalItemCount)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)value).unlockableName);
         }
         if (value < TotalItemCount + TotalEquipmentCount)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(value - TotalItemCount)).unlockableName);
         }
     }
     return("");
 }
Example #13
0
 public bool IsBoss()
 {
     if (value >= 0)
     {
         if (value < TotalItemCount)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)value).tier == ItemTier.Boss);
         }
         if (value < TotalItemCount + TotalEquipmentCount)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(value - TotalItemCount)).isBoss);
         }
     }
     return(false);
 }
        // Token: 0x06000EFA RID: 3834 RVA: 0x00049B54 File Offset: 0x00047D54
        private void Execute()
        {
            EquipmentIndex equipmentIndex = this.equipmentIndex;

            if (EquipmentCatalog.GetEquipmentDef(equipmentIndex) != null && this.subcooldownTimer <= 0f && this.PerformEquipmentAction(equipmentIndex))
            {
                this.inventory.DeductActiveEquipmentCharges(1);
                this.CallRpcOnClientEquipmentActivationRecieved();
                Action <EquipmentSlot, EquipmentIndex> action = EquipmentSlot.onServerEquipmentActivated;
                if (action == null)
                {
                    return;
                }
                action(this, equipmentIndex);
            }
        }
Example #15
0
        // Token: 0x060015BF RID: 5567 RVA: 0x0005CB68 File Offset: 0x0005AD68
        public override void OverrideRuleChoices(RuleChoiceMask mustInclude, RuleChoiceMask mustExclude)
        {
            base.OverrideRuleChoices(mustInclude, mustExclude);
            base.ForceChoice(mustInclude, mustExclude, "Difficulty.Normal");
            base.ForceChoice(mustInclude, mustExclude, "Misc.StartingMoney.50");
            base.ForceChoice(mustInclude, mustExclude, "Misc.StageOrder.Random");
            base.ForceChoice(mustInclude, mustExclude, "Misc.KeepMoneyBetweenStages.Off");
            for (ArtifactIndex artifactIndex = ArtifactIndex.Command; artifactIndex < ArtifactIndex.Count; artifactIndex++)
            {
                RuleDef       ruleDef       = RuleCatalog.FindRuleDef(artifactIndex.ToString());
                RuleChoiceDef ruleChoiceDef = (ruleDef != null) ? ruleDef.FindChoice("Off") : null;
                if (ruleChoiceDef != null)
                {
                    base.ForceChoice(mustInclude, mustExclude, ruleChoiceDef);
                }
            }
            ItemIndex itemIndex = ItemIndex.Syringe;
            ItemIndex itemCount = (ItemIndex)ItemCatalog.itemCount;

            while (itemIndex < itemCount)
            {
                ItemDef       itemDef        = ItemCatalog.GetItemDef(itemIndex);
                RuleDef       ruleDef2       = RuleCatalog.FindRuleDef("Items." + itemDef.name);
                RuleChoiceDef ruleChoiceDef2 = (ruleDef2 != null) ? ruleDef2.FindChoice("On") : null;
                if (ruleChoiceDef2 != null)
                {
                    base.ForceChoice(mustInclude, mustExclude, ruleChoiceDef2);
                }
                itemIndex++;
            }
            EquipmentIndex equipmentIndex = EquipmentIndex.CommandMissile;
            EquipmentIndex equipmentCount = (EquipmentIndex)EquipmentCatalog.equipmentCount;

            while (equipmentIndex < equipmentCount)
            {
                EquipmentDef  equipmentDef   = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
                RuleDef       ruleDef3       = RuleCatalog.FindRuleDef("Equipment." + equipmentDef.name);
                RuleChoiceDef ruleChoiceDef3 = (ruleDef3 != null) ? ruleDef3.FindChoice("On") : null;
                if (ruleChoiceDef3 != null)
                {
                    base.ForceChoice(mustInclude, mustExclude, ruleChoiceDef3);
                }
                equipmentIndex++;
            }
        }
Example #16
0
 // Token: 0x06001927 RID: 6439 RVA: 0x00078D04 File Offset: 0x00076F04
 public Color GetPickupColorDark()
 {
     if (this.value >= 0)
     {
         if (this.value < 78)
         {
             return(ColorCatalog.GetColor(ItemCatalog.GetItemDef((ItemIndex)this.value).darkColorIndex));
         }
         if (this.value < 105)
         {
             return(ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(this.value - 78)).colorIndex));
         }
         if (this.value < 106)
         {
             return(ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarItem));
         }
     }
     return(Color.black);
 }
Example #17
0
 public Color GetPickupColorDark()
 {
     if (value >= 0)
     {
         if (value < TotalItemCount)
         {
             return(ColorCatalog.GetColor(ItemCatalog.GetItemDef((ItemIndex)value).darkColorIndex));
         }
         if (value < TotalItemCount + TotalEquipmentCount)
         {
             return(ColorCatalog.GetColor(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(value - TotalItemCount)).colorIndex));
         }
         if (value < TotalItemCount + TotalEquipmentCount + CoinCount)
         {
             return(ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarItem));
         }
     }
     return(Color.black);
 }
Example #18
0
 public string GetPickupNameToken()
 {
     if (value >= 0)
     {
         if (value < TotalItemCount)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)value).nameToken);
         }
         if (value < TotalItemCount + TotalEquipmentCount)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(value - TotalItemCount)).nameToken);
         }
         if (value < TotalItemCount + TotalEquipmentCount + CoinCount)
         {
             return("PICKUP_LUNAR_COIN");
         }
     }
     return("???");
 }
Example #19
0
 // Token: 0x06001928 RID: 6440 RVA: 0x00078D84 File Offset: 0x00076F84
 public string GetPickupNameToken()
 {
     if (this.value >= 0)
     {
         if (this.value < 78)
         {
             return(ItemCatalog.GetItemDef((ItemIndex)this.value).nameToken);
         }
         if (this.value < 105)
         {
             return(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(this.value - 78)).nameToken);
         }
         if (this.value < 106)
         {
             return("PICKUP_LUNAR_COIN");
         }
     }
     return("???");
 }
Example #20
0
 // Token: 0x06001924 RID: 6436 RVA: 0x00078B6C File Offset: 0x00076D6C
 public GameObject GetPickupDisplayPrefab()
 {
     if (this.value >= 0)
     {
         if (this.value < 78)
         {
             return(Resources.Load <GameObject>(ItemCatalog.GetItemDef((ItemIndex)this.value).pickupModelPath));
         }
         if (this.value < 105)
         {
             return(Resources.Load <GameObject>(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)(this.value - 78)).pickupModelPath));
         }
         if (this.value < 106)
         {
             return(Resources.Load <GameObject>("Prefabs/PickupModels/PickupLunarCoin"));
         }
     }
     return(null);
 }
Example #21
0
        // Token: 0x06000E12 RID: 3602 RVA: 0x0003ED4C File Offset: 0x0003CF4C
        private MageElement CalcElementToAward()
        {
            for (int i = 0; i < MageCalibrationController.elementCounter.Length; i++)
            {
                MageCalibrationController.elementCounter[i] = 0;
            }
            Inventory inventory = this.characterBody.inventory;

            if (!inventory)
            {
                return(MageElement.None);
            }
            List <ItemIndex> itemAcquisitionOrder = inventory.itemAcquisitionOrder;

            for (int j = 0; j < itemAcquisitionOrder.Count; j++)
            {
                ItemCatalog.GetItemDef(itemAcquisitionOrder[j]);
            }
            EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(inventory.currentEquipmentIndex);

            if (equipmentDef != null && equipmentDef.mageElement != MageElement.None)
            {
                MageCalibrationController.elementCounter[(int)equipmentDef.mageElement] += 2;
            }
            MageElement result = MageElement.None;
            int         num    = 0;

            for (MageElement mageElement = MageElement.Fire; mageElement < MageElement.Count; mageElement += 1)
            {
                int num2 = MageCalibrationController.elementCounter[(int)mageElement];
                if (num2 > num)
                {
                    result = mageElement;
                    num    = num2;
                }
            }
            if (num >= 5)
            {
                return(result);
            }
            return(MageElement.None);
        }
        // Token: 0x060018D8 RID: 6360 RVA: 0x0006AFB8 File Offset: 0x000691B8
        public static RuleDef FromEquipment(EquipmentIndex equipmentIndex)
        {
            EquipmentDef  equipmentDef  = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
            RuleDef       ruleDef       = new RuleDef("Equipment." + equipmentIndex.ToString(), equipmentDef.nameToken);
            RuleChoiceDef ruleChoiceDef = ruleDef.AddChoice("On", null, false);

            ruleChoiceDef.spritePath              = equipmentDef.pickupIconPath;
            ruleChoiceDef.tooltipBodyToken        = equipmentDef.nameToken;
            ruleChoiceDef.unlockableName          = equipmentDef.unlockableName;
            ruleChoiceDef.equipmentIndex          = equipmentIndex;
            ruleChoiceDef.availableInMultiPlayer  = equipmentDef.appearsInMultiPlayer;
            ruleChoiceDef.availableInSinglePlayer = equipmentDef.appearsInSinglePlayer;
            ruleDef.MakeNewestChoiceDefault();
            RuleChoiceDef ruleChoiceDef2 = ruleDef.AddChoice("Off", null, false);

            ruleChoiceDef2.spritePath       = equipmentDef.pickupIconPath;
            ruleChoiceDef2.materialPath     = "Materials/UI/matRuleChoiceOff";
            ruleChoiceDef2.tooltipBodyToken = null;
            return(ruleDef);
        }
Example #23
0
        public static List <EquipmentIndex> GetDefaultEquipmentDropList()
        {
            var list = new List <EquipmentIndex>();

            for (EquipmentIndex equipmentIndex = EquipmentIndex.CommandMissile; equipmentIndex < EquipmentIndex.Count; equipmentIndex++)
            {
                if (Run.instance.availableEquipment.HasEquipment(equipmentIndex))
                {
                    EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(equipmentIndex);
                    if (equipmentDef.canDrop)
                    {
                        if (!equipmentDef.isLunar)
                        {
                            list.Add(equipmentIndex);
                        }
                    }
                }
            }

            return(list);
        }
Example #24
0
 // Token: 0x06000AEA RID: 2794 RVA: 0x00035C0C File Offset: 0x00033E0C
 static EquipmentCatalog()
 {
     EquipmentCatalog.equipmentDefs = new EquipmentDef[27];
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Blackhole, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupGravCube",
         pickupIconPath   = "Textures/ItemIcons/texGravCubeIcon",
         nameToken        = "EQUIPMENT_BLACKHOLE_NAME",
         pickupToken      = "EQUIPMENT_BLACKHOLE_PICKUP",
         descriptionToken = "EQUIPMENT_BLACKHOLE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CommandMissile, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupMissileRack",
         pickupIconPath   = "Textures/ItemIcons/texMissileRackIcon",
         nameToken        = "EQUIPMENT_COMMANDMISSILE_NAME",
         pickupToken      = "EQUIPMENT_COMMANDMISSILE_PICKUP",
         descriptionToken = "EQUIPMENT_COMMANDMISSILE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.OrbitalLaser, new EquipmentDef
     {
         cooldown         = 1f,
         nameToken        = "EQUIPMENT_ORBITALLASER_NAME",
         pickupToken      = "EQUIPMENT_ORBITALLASER_PICKUP",
         descriptionToken = "EQUIPMENT_ORBITALLASER_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Saw, new EquipmentDef
     {
         cooldown         = 45f,
         nameToken        = "EQUIPMENT_SAW_NAME",
         pickupToken      = "EQUIPMENT_SAW_PICKUP",
         descriptionToken = "EQUIPMENT_SAW_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Fruit, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupFruit",
         pickupIconPath   = "Textures/ItemIcons/texFruitIcon",
         nameToken        = "EQUIPMENT_FRUIT_NAME",
         pickupToken      = "EQUIPMENT_FRUIT_PICKUP",
         descriptionToken = "EQUIPMENT_FRUIT_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Meteor, new EquipmentDef
     {
         cooldown         = 140f,
         pickupModelPath  = "Prefabs/PickupModels/PickupMeteor",
         pickupIconPath   = "Textures/ItemIcons/texMeteorIcon",
         nameToken        = "EQUIPMENT_METEOR_NAME",
         pickupToken      = "EQUIPMENT_METEOR_PICKUP",
         descriptionToken = "EQUIPMENT_METEOR_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = false,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem,
         unlockableName   = "Items.Meteor"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.SoulJar, new EquipmentDef
     {
         cooldown         = 45f,
         nameToken        = "EQUIPMENT_SOULJAR_NAME",
         pickupToken      = "EQUIPMENT_SOULJAR_PICKUP",
         descriptionToken = "EQUIPMENT_SOULJAR_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.GhostGun, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupGhostRevolver",
         nameToken        = "EQUIPMENT_GHOSTGUN_NAME",
         pickupToken      = "EQUIPMENT_GHOSTGUN_PICKUP",
         descriptionToken = "EQUIPMENT_GHOSTGUN_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CritOnUse, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupNeuralImplant",
         pickupIconPath   = "Textures/ItemIcons/texNeuralImplantIcon",
         nameToken        = "EQUIPMENT_CRITONUSE_NAME",
         pickupToken      = "EQUIPMENT_CRITONUSE_PICKUP",
         descriptionToken = "EQUIPMENT_CRITONUSE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixRed, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixRed",
         pickupIconPath   = "Textures/ItemIcons/texAffixRedIcon",
         nameToken        = "EQUIPMENT_AFFIXRED_NAME",
         pickupToken      = "EQUIPMENT_AFFIXRED_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXRED_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixRed
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixGreen, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixGreen",
         pickupIconPath   = "Textures/ItemIcons/texAffixGreenIcon",
         nameToken        = "EQUIPMENT_AFFIXGREEN_NAME",
         pickupToken      = "EQUIPMENT_AFFIXGREEN_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXGREEN_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.None
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixBlue, new EquipmentDef
     {
         cooldown         = 25f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixBlue",
         pickupIconPath   = "Textures/ItemIcons/texAffixBlueIcon",
         nameToken        = "EQUIPMENT_AFFIXBLUE_NAME",
         pickupToken      = "EQUIPMENT_AFFIXBLUE_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXBLUE_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixBlue
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixYellow, new EquipmentDef
     {
         cooldown         = 25f,
         nameToken        = "",
         pickupToken      = "",
         descriptionToken = "",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.None
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixGold, new EquipmentDef
     {
         cooldown         = 25f,
         nameToken        = "EQUIPMENT_AFFIXGOLD_NAME",
         pickupToken      = "EQUIPMENT_AFFIXGOLD_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXGOLD_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.None
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixWhite, new EquipmentDef
     {
         cooldown         = 25f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixWhite",
         pickupIconPath   = "Textures/ItemIcons/texAffixWhiteIcon",
         nameToken        = "EQUIPMENT_AFFIXWHITE_NAME",
         pickupToken      = "EQUIPMENT_AFFIXWHITE_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXWHITE_DESC",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixWhite
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.DroneBackup, new EquipmentDef
     {
         cooldown         = 100f,
         pickupModelPath  = "Prefabs/PickupModels/PickupRadio",
         pickupIconPath   = "Textures/ItemIcons/texRadioIcon",
         nameToken        = "EQUIPMENT_DRONEBACKUP_NAME",
         pickupToken      = "EQUIPMENT_DRONEBACKUP_PICKUP",
         descriptionToken = "EQUIPMENT_DRONEBACKUP_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.DroneBackup"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.BFG, new EquipmentDef
     {
         cooldown         = 140f,
         pickupModelPath  = "Prefabs/PickupModels/PickupBFG",
         pickupIconPath   = "Textures/ItemIcons/texBFGIcon",
         nameToken        = "EQUIPMENT_BFG_NAME",
         pickupToken      = "EQUIPMENT_BFG_PICKUP",
         descriptionToken = "EQUIPMENT_BFG_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.BFG"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Enigma, new EquipmentDef
     {
         cooldown         = 60f,
         pickupIconPath   = "Textures/ItemIcons/texEnigmaIcon",
         nameToken        = "EQUIPMENT_ENIGMA_NAME",
         pickupToken      = "EQUIPMENT_ENIGMA_PICKUP",
         descriptionToken = "EQUIPMENT_ENIGMA_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Jetpack, new EquipmentDef
     {
         cooldown         = 60f,
         pickupIconPath   = "Textures/ItemIcons/texChrysalisIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupChrysalis",
         nameToken        = "EQUIPMENT_JETPACK_NAME",
         pickupToken      = "EQUIPMENT_JETPACK_PICKUP",
         descriptionToken = "EQUIPMENT_JETPACK_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Lightning, new EquipmentDef
     {
         cooldown         = 20f,
         pickupIconPath   = "Textures/ItemIcons/texCapacitorIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupCapacitor",
         nameToken        = "EQUIPMENT_LIGHTNING_NAME",
         pickupToken      = "EQUIPMENT_LIGHTNING_PICKUP",
         descriptionToken = "EQUIPMENT_LIGHTNING_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         mageElement      = MageElement.Lightning,
         unlockableName   = "Items.Lightning"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.GoldGat, new EquipmentDef
     {
         cooldown         = 5f,
         pickupIconPath   = "Textures/ItemIcons/texGoldGatIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupGoldGat",
         nameToken        = "EQUIPMENT_GOLDGAT_NAME",
         pickupToken      = "EQUIPMENT_GOLDGAT_PICKUP",
         descriptionToken = "EQUIPMENT_GOLDGAT_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = false,
         unlockableName   = "Items.GoldGat"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.PassiveHealing, new EquipmentDef
     {
         cooldown              = 15f,
         pickupIconPath        = "Textures/ItemIcons/texWoodspriteIcon",
         pickupModelPath       = "Prefabs/PickupModels/PickupWoodsprite",
         nameToken             = "EQUIPMENT_PASSIVEHEALING_NAME",
         pickupToken           = "EQUIPMENT_PASSIVEHEALING_PICKUP",
         descriptionToken      = "EQUIPMENT_PASSIVEHEALING_DESC",
         addressToken          = "",
         canDrop               = true,
         enigmaCompatible      = false,
         appearsInSinglePlayer = true,
         unlockableName        = "Items.PassiveHealing"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.LunarPotion, new EquipmentDef
     {
         cooldown         = 5f,
         pickupIconPath   = null,
         pickupModelPath  = null,
         nameToken        = "EQUIPMENT_LUNARPOTION_NAME",
         pickupToken      = "EQUIPMENT_LUNARPOTION_NAME",
         descriptionToken = "EQUIPMENT_LUNARPOTION_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.BurnNearby, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupPotion",
         pickupIconPath   = "Textures/ItemIcons/texPotionIcon",
         nameToken        = "EQUIPMENT_BURNNEARBY_NAME",
         pickupToken      = "EQUIPMENT_BURNNEARBY_PICKUP",
         descriptionToken = "EQUIPMENT_BURNNEARBY_DESC",
         unlockableName   = "Items.BurnNearby",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.SoulCorruptor, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = null,
         pickupIconPath   = null,
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Scanner, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupScanner",
         pickupIconPath   = "Textures/ItemIcons/texScannerIcon",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.Scanner"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CrippleWard, new EquipmentDef
     {
         cooldown         = 15f,
         pickupModelPath  = "Prefabs/PickupModels/PickupEffigy",
         pickupIconPath   = "Textures/ItemIcons/texEffigyIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem
     });
     for (EquipmentIndex equipmentIndex = EquipmentIndex.CommandMissile; equipmentIndex < EquipmentIndex.Count; equipmentIndex++)
     {
         if (EquipmentCatalog.GetEquipmentDef(equipmentIndex) == null)
         {
             Debug.LogErrorFormat("Equipment {0} is unregistered!", new object[]
             {
                 equipmentIndex
             });
         }
     }
 }
Example #25
0
        static patch_RuleCatalog()
        {
            allRuleDefs                = new List <RuleDef>();
            allChoicesDefs             = new List <RuleChoiceDef>();
            allCategoryDefs            = new List <RuleCategoryDef>();
            ruleDefsByGlobalName       = new Dictionary <string, RuleDef>();
            ruleChoiceDefsByGlobalName = new Dictionary <string, RuleChoiceDef>();
            ruleShowItems              = new BoolConVar("rule_show_items", ConVarFlags.None, "1",
                                                        "Whether or not to allow voting on items in the pregame rules.");
            RuleCatalog.AddCategory("RULE_HEADER_DIFFICULTY", new Color32(28, 99, 150, byte.MaxValue));
            RuleCatalog.AddRule(RuleDef.FromDifficulty());
            RuleCatalog.AddCategory("RULE_HEADER_ARTIFACTS", new Color32(74, 50, 149, byte.MaxValue), null,
                                    RuleCatalog.HiddenTestFalse);
            for (ArtifactIndex artifactIndex = 0; artifactIndex < ArtifactIndex.Count; artifactIndex++)
            {
                RuleCatalog.AddRule(RuleDef.FromArtifact(artifactIndex));
            }

            RuleCatalog.AddCategory("RULE_HEADER_ITEMS", new Color32(147, 225, 128, byte.MaxValue), null,
                                    RuleCatalog.HiddenTestItemsConvar);
            var list = new List <ItemIndex>();

            for (ItemIndex itemIndex = 0; itemIndex < ItemIndex.Count; itemIndex++)
            {
                list.Add(itemIndex);
            }

            foreach (var itemIndex2 in from i in list
                     where ItemCatalog.GetItemDef(i).inDroppableTier
                     orderby ItemCatalog.GetItemDef(i).tier
                     select i)
            {
                RuleCatalog.AddRule(RuleDef.FromItem(itemIndex2));
            }

            RuleCatalog.AddCategory("RULE_HEADER_EQUIPMENT", new Color32(byte.MaxValue, 128, 0, byte.MaxValue), null,
                                    RuleCatalog.HiddenTestItemsConvar);
            var list2 = new List <EquipmentIndex>();

            for (EquipmentIndex equipmentIndex = 0; equipmentIndex < EquipmentIndex.Count; equipmentIndex++)
            {
                list2.Add(equipmentIndex);
            }

            foreach (var equipmentIndex2 in from i in list2
                     where EquipmentCatalog.GetEquipmentDef(i).canDrop
                     select i)
            {
                RuleCatalog.AddRule(RuleDef.FromEquipment(equipmentIndex2));
            }

            RuleCatalog.AddCategory("RULE_HEADER_MISC", new Color32(192, 192, 192, byte.MaxValue), null,
                                    RuleCatalog.HiddenTestFalse);
            var ruleDef       = new RuleDef("Misc.StartingMoney", "RULE_MISC_STARTING_MONEY");
            var ruleChoiceDef = ruleDef.AddChoice("0", 0, true);

            ruleChoiceDef.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_0_NAME";
            ruleChoiceDef.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_0_DESC";
            ruleChoiceDef.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            var ruleChoiceDef2 = ruleDef.AddChoice("15", 15, true);

            ruleChoiceDef2.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_15_NAME";
            ruleChoiceDef2.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_15_DESC";
            ruleChoiceDef2.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            ruleDef.MakeNewestChoiceDefault();
            var ruleChoiceDef3 = ruleDef.AddChoice("50", 50, true);

            ruleChoiceDef3.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_50_NAME";
            ruleChoiceDef3.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_50_DESC";
            ruleChoiceDef3.spritePath       = "Textures/MiscIcons/texRuleBonusStartingMoney";
            ruleChoiceDef3.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            RuleCatalog.AddRule(ruleDef);
            var ruleDef2       = new RuleDef("Misc.StageOrder", "RULE_MISC_STAGE_ORDER");
            var ruleChoiceDef4 = ruleDef2.AddChoice("Normal", 0, true);

            ruleChoiceDef4.tooltipNameToken = "RULE_STAGEORDER_CHOICE_NORMAL_NAME";
            ruleChoiceDef4.tooltipBodyToken = "RULE_STAGEORDER_CHOICE_NORMAL_DESC";
            ruleChoiceDef4.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            ruleDef2.MakeNewestChoiceDefault();
            var ruleChoiceDef5 = ruleDef2.AddChoice("Random", 1, true);

            ruleChoiceDef5.tooltipNameToken = "RULE_STAGEORDER_CHOICE_RANDOM_NAME";
            ruleChoiceDef5.tooltipBodyToken = "RULE_STAGEORDER_CHOICE_RANDOM_DESC";
            ruleChoiceDef5.spritePath       = "Textures/MiscIcons/texRuleMapIsRandom";
            ruleChoiceDef5.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            RuleCatalog.AddRule(ruleDef2);
            var ruleDef3 = new RuleDef("Misc.KeepMoneyBetweenStages", "RULE_MISC_KEEP_MONEY_BETWEEN_STAGES");

            ruleDef3.AddChoice("On", 1, true).tooltipBodyToken  = "RULE_KEEPMONEYBETWEENSTAGES_CHOICE_ON_DESC";
            ruleDef3.AddChoice("Off", 0, true).tooltipBodyToken = "RULE_KEEPMONEYBETWEENSTAGES_CHOICE_OFF_DESC";
            ruleDef3.MakeNewestChoiceDefault();
            RuleCatalog.AddRule(ruleDef3);
            for (var k = 0; k < RuleCatalog.allRuleDefs.Count; k++)
            {
                var ruleDef4 = RuleCatalog.allRuleDefs[k];
                ruleDef4.globalIndex = k;
                for (var j = 0; j < ruleDef4.choices.Count; j++)
                {
                    var ruleChoiceDef6 = ruleDef4.choices[j];
                    ruleChoiceDef6.localIndex  = j;
                    ruleChoiceDef6.globalIndex = RuleCatalog.allChoicesDefs.Count;
                    RuleCatalog.allChoicesDefs.Add(ruleChoiceDef6);
                }
            }

            RuleCatalog.availability.MakeAvailable();
        }
Example #26
0
        // Token: 0x060004F2 RID: 1266 RVA: 0x00013E8C File Offset: 0x0001208C
        private void GenerateRuntimeValues()
        {
            this.runtimeItemRuleGroups      = new DisplayRuleGroup[ItemCatalog.itemCount];
            this.runtimeEquipmentRuleGroups = new DisplayRuleGroup[EquipmentCatalog.equipmentCount];
            int i         = 0;
            int itemCount = ItemCatalog.itemCount;

            while (i < itemCount)
            {
                this.runtimeItemRuleGroups[i] = this.FindItemDisplayRuleGroup(ItemCatalog.GetItemDef((ItemIndex)i).name);
                i++;
            }
            int j = 0;
            int equipmentCount = EquipmentCatalog.equipmentCount;

            while (j < equipmentCount)
            {
                this.runtimeEquipmentRuleGroups[j] = this.FindEquipmentDisplayRuleGroup(EquipmentCatalog.GetEquipmentDef((EquipmentIndex)j).name);
                j++;
            }
        }
        // Token: 0x0600117F RID: 4479 RVA: 0x00056D90 File Offset: 0x00054F90
        private MageElement CalcElementToAward()
        {
            for (int i = 0; i < MageCalibrationController.elementCounter.Length; i++)
            {
                MageCalibrationController.elementCounter[i] = 0;
            }
            Inventory inventory = this.characterBody.inventory;

            if (!inventory)
            {
                return(MageElement.None);
            }
            List <ItemIndex> itemAcquisitionOrder = inventory.itemAcquisitionOrder;

            for (int j = 0; j < itemAcquisitionOrder.Count; j++)
            {
                ItemIndex itemIndex = itemAcquisitionOrder[j];
                ItemDef   itemDef   = ItemCatalog.GetItemDef(itemIndex);
                if (itemDef.mageElement != MageElement.None)
                {
                    int num = 0;
                    switch (itemDef.tier)
                    {
                    case ItemTier.Tier1:
                        num = 1;
                        break;

                    case ItemTier.Tier2:
                        num = 2;
                        break;

                    case ItemTier.Tier3:
                        num = 3;
                        break;

                    case ItemTier.Lunar:
                        num = 3;
                        break;
                    }
                    MageCalibrationController.elementCounter[(int)itemDef.mageElement] += num * inventory.GetItemCount(itemIndex);
                }
            }
            EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(inventory.currentEquipmentIndex);

            if (equipmentDef != null && equipmentDef.mageElement != MageElement.None)
            {
                MageCalibrationController.elementCounter[(int)equipmentDef.mageElement] += 2;
            }
            MageElement result = MageElement.None;
            int         num2   = 0;

            for (MageElement mageElement = MageElement.Fire; mageElement < MageElement.Count; mageElement += 1)
            {
                int num3 = MageCalibrationController.elementCounter[(int)mageElement];
                if (num3 > num2)
                {
                    result = mageElement;
                    num2   = num3;
                }
            }
            if (num2 >= 5)
            {
                return(result);
            }
            return(MageElement.None);
        }
 // Token: 0x06000576 RID: 1398 RVA: 0x000161BC File Offset: 0x000143BC
 public bool HasEquipment(EquipmentIndex equipmentIndex)
 {
     return(EquipmentCatalog.IsIndexValid(equipmentIndex) && (this.a & 1UL << (int)equipmentIndex) > 0UL);
 }
        private static void Init()
        {
            RuleCatalog.AddCategory("RULE_HEADER_DIFFICULTY", new Color32(28, 99, 150, byte.MaxValue));
            RuleCatalog.AddRule(RuleDef.FromDifficulty());
            RuleCatalog.AddCategory("RULE_HEADER_ARTIFACTS", new Color32(74, 50, 149, byte.MaxValue), "RULE_ARTIFACTS_EMPTY_TIP", new Func <bool>(RuleCatalog.HiddenTestFalse));
            for (ArtifactIndex artifactIndex = ArtifactIndex.Command; artifactIndex < ArtifactIndex.Count; artifactIndex++)
            {
                RuleCatalog.AddRule(RuleDef.FromArtifact(artifactIndex));
            }
            RuleCatalog.AddCategory("RULE_HEADER_ITEMS", new Color32(147, 225, 128, byte.MaxValue), null, new Func <bool>(RuleCatalog.HiddenTestItemsConvar));
            List <ItemIndex> list      = new List <ItemIndex>();
            ItemIndex        itemIndex = ItemIndex.Syringe;
            ItemIndex        itemCount = (ItemIndex)ItemCatalog.itemCount;

            while (itemIndex < itemCount)
            {
                list.Add(itemIndex);
                itemIndex++;
            }
            foreach (ItemIndex itemIndex2 in from i in list
                     where ItemCatalog.GetItemDef(i).inDroppableTier
                     orderby ItemCatalog.GetItemDef(i).tier
                     select i)
            {
                RuleCatalog.AddRule(RuleDef.FromItem(itemIndex2));
            }
            RuleCatalog.AddCategory("RULE_HEADER_EQUIPMENT", new Color32(byte.MaxValue, 128, 0, byte.MaxValue), null, new Func <bool>(RuleCatalog.HiddenTestItemsConvar));
            List <EquipmentIndex> list2          = new List <EquipmentIndex>();
            EquipmentIndex        equipmentIndex = EquipmentIndex.CommandMissile;
            EquipmentIndex        equipmentCount = (EquipmentIndex)EquipmentCatalog.equipmentCount;

            while (equipmentIndex < equipmentCount)
            {
                list2.Add(equipmentIndex);
                equipmentIndex++;
            }
            foreach (EquipmentIndex equipmentIndex2 in from i in list2
                     where EquipmentCatalog.GetEquipmentDef(i).canDrop
                     select i)
            {
                RuleCatalog.AddRule(RuleDef.FromEquipment(equipmentIndex2));
            }
            RuleCatalog.AddCategory("RULE_HEADER_MISC", new Color32(192, 192, 192, byte.MaxValue), null, new Func <bool>(RuleCatalog.HiddenTestFalse));
            RuleDef       ruleDef       = new RuleDef("Misc.StartingMoney", "RULE_MISC_STARTING_MONEY");
            RuleChoiceDef ruleChoiceDef = ruleDef.AddChoice("0", 0U, true);

            ruleChoiceDef.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_0_NAME";
            ruleChoiceDef.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_0_DESC";
            ruleChoiceDef.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            RuleChoiceDef ruleChoiceDef2 = ruleDef.AddChoice("15", 15U, true);

            ruleChoiceDef2.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_15_NAME";
            ruleChoiceDef2.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_15_DESC";
            ruleChoiceDef2.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            ruleDef.MakeNewestChoiceDefault();
            RuleChoiceDef ruleChoiceDef3 = ruleDef.AddChoice("50", 50U, true);

            ruleChoiceDef3.tooltipNameToken = "RULE_STARTINGMONEY_CHOICE_50_NAME";
            ruleChoiceDef3.tooltipBodyToken = "RULE_STARTINGMONEY_CHOICE_50_DESC";
            ruleChoiceDef3.spritePath       = "Textures/MiscIcons/texRuleBonusStartingMoney";
            ruleChoiceDef3.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            RuleCatalog.AddRule(ruleDef);
            RuleDef       ruleDef2       = new RuleDef("Misc.StageOrder", "RULE_MISC_STAGE_ORDER");
            RuleChoiceDef ruleChoiceDef4 = ruleDef2.AddChoice("Normal", StageOrder.Normal, true);

            ruleChoiceDef4.tooltipNameToken = "RULE_STAGEORDER_CHOICE_NORMAL_NAME";
            ruleChoiceDef4.tooltipBodyToken = "RULE_STAGEORDER_CHOICE_NORMAL_DESC";
            ruleChoiceDef4.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            ruleDef2.MakeNewestChoiceDefault();
            RuleChoiceDef ruleChoiceDef5 = ruleDef2.AddChoice("Random", StageOrder.Random, true);

            ruleChoiceDef5.tooltipNameToken = "RULE_STAGEORDER_CHOICE_RANDOM_NAME";
            ruleChoiceDef5.tooltipBodyToken = "RULE_STAGEORDER_CHOICE_RANDOM_DESC";
            ruleChoiceDef5.spritePath       = "Textures/MiscIcons/texRuleMapIsRandom";
            ruleChoiceDef5.tooltipNameColor = ColorCatalog.GetColor(ColorCatalog.ColorIndex.LunarCoin);
            RuleCatalog.AddRule(ruleDef2);
            RuleDef ruleDef3 = new RuleDef("Misc.KeepMoneyBetweenStages", "RULE_MISC_KEEP_MONEY_BETWEEN_STAGES");

            ruleDef3.AddChoice("On", true, true).tooltipBodyToken   = "RULE_KEEPMONEYBETWEENSTAGES_CHOICE_ON_DESC";
            ruleDef3.AddChoice("Off", false, true).tooltipBodyToken = "RULE_KEEPMONEYBETWEENSTAGES_CHOICE_OFF_DESC";
            ruleDef3.MakeNewestChoiceDefault();
            RuleCatalog.AddRule(ruleDef3);
            for (int k = 0; k < RuleCatalog.allRuleDefs.Count; k++)
            {
                RuleDef ruleDef4 = RuleCatalog.allRuleDefs[k];
                ruleDef4.globalIndex = k;
                for (int j = 0; j < ruleDef4.choices.Count; j++)
                {
                    RuleChoiceDef ruleChoiceDef6 = ruleDef4.choices[j];
                    ruleChoiceDef6.localIndex  = j;
                    ruleChoiceDef6.globalIndex = RuleCatalog.allChoicesDefs.Count;
                    RuleCatalog.allChoicesDefs.Add(ruleChoiceDef6);
                }
            }
            RuleCatalog.availability.MakeAvailable();
        }
Example #30
0
 private static void Init()
 {
     EquipmentCatalog.equipmentNameToIndex.Clear();
     Array.Resize <EquipmentDef>(ref EquipmentCatalog.equipmentDefs, 34);
     EquipmentCatalog.equipmentCount = EquipmentCatalog.equipmentDefs.Length;
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Blackhole, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupGravCube",
         pickupIconPath   = "Textures/ItemIcons/texGravCubeIcon",
         nameToken        = "EQUIPMENT_BLACKHOLE_NAME",
         pickupToken      = "EQUIPMENT_BLACKHOLE_PICKUP",
         descriptionToken = "EQUIPMENT_BLACKHOLE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CommandMissile, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupMissileRack",
         pickupIconPath   = "Textures/ItemIcons/texMissileRackIcon",
         nameToken        = "EQUIPMENT_COMMANDMISSILE_NAME",
         pickupToken      = "EQUIPMENT_COMMANDMISSILE_PICKUP",
         descriptionToken = "EQUIPMENT_COMMANDMISSILE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.OrbitalLaser, new EquipmentDef
     {
         cooldown         = 1f,
         nameToken        = "EQUIPMENT_ORBITALLASER_NAME",
         pickupToken      = "EQUIPMENT_ORBITALLASER_PICKUP",
         descriptionToken = "EQUIPMENT_ORBITALLASER_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Saw, new EquipmentDef
     {
         cooldown         = 45f,
         nameToken        = "EQUIPMENT_SAW_NAME",
         pickupToken      = "EQUIPMENT_SAW_PICKUP",
         descriptionToken = "EQUIPMENT_SAW_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Fruit, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupFruit",
         pickupIconPath   = "Textures/ItemIcons/texFruitIcon",
         nameToken        = "EQUIPMENT_FRUIT_NAME",
         pickupToken      = "EQUIPMENT_FRUIT_PICKUP",
         descriptionToken = "EQUIPMENT_FRUIT_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Meteor, new EquipmentDef
     {
         cooldown         = 140f,
         pickupModelPath  = "Prefabs/PickupModels/PickupMeteor",
         pickupIconPath   = "Textures/ItemIcons/texMeteorIcon",
         nameToken        = "EQUIPMENT_METEOR_NAME",
         pickupToken      = "EQUIPMENT_METEOR_PICKUP",
         descriptionToken = "EQUIPMENT_METEOR_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = false,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem,
         unlockableName   = "Items.Meteor"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.SoulJar, new EquipmentDef
     {
         cooldown         = 45f,
         nameToken        = "EQUIPMENT_SOULJAR_NAME",
         pickupToken      = "EQUIPMENT_SOULJAR_PICKUP",
         descriptionToken = "EQUIPMENT_SOULJAR_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.GhostGun, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupGhostRevolver",
         nameToken        = "EQUIPMENT_GHOSTGUN_NAME",
         pickupToken      = "EQUIPMENT_GHOSTGUN_PICKUP",
         descriptionToken = "EQUIPMENT_GHOSTGUN_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CritOnUse, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupNeuralImplant",
         pickupIconPath   = "Textures/ItemIcons/texNeuralImplantIcon",
         nameToken        = "EQUIPMENT_CRITONUSE_NAME",
         pickupToken      = "EQUIPMENT_CRITONUSE_PICKUP",
         descriptionToken = "EQUIPMENT_CRITONUSE_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixRed, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixRed",
         pickupIconPath   = "Textures/ItemIcons/texAffixRedIcon",
         nameToken        = "EQUIPMENT_AFFIXRED_NAME",
         pickupToken      = "EQUIPMENT_AFFIXRED_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXRED_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixRed
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixPoison, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixPoison",
         pickupIconPath   = "Textures/ItemIcons/texAffixPoisonIcon",
         nameToken        = "EQUIPMENT_AFFIXPOISON_NAME",
         pickupToken      = "EQUIPMENT_AFFIXPOISON_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXPOISON_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixPoison
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixBlue, new EquipmentDef
     {
         cooldown         = 25f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixBlue",
         pickupIconPath   = "Textures/ItemIcons/texAffixBlueIcon",
         nameToken        = "EQUIPMENT_AFFIXBLUE_NAME",
         pickupToken      = "EQUIPMENT_AFFIXBLUE_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXBLUE_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixBlue
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixYellow, new EquipmentDef
     {
         cooldown         = 25f,
         nameToken        = "",
         pickupToken      = "",
         descriptionToken = "",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.None
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixGold, new EquipmentDef
     {
         cooldown         = 25f,
         nameToken        = "EQUIPMENT_AFFIXGOLD_NAME",
         pickupToken      = "EQUIPMENT_AFFIXGOLD_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXGOLD_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.None
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixWhite, new EquipmentDef
     {
         cooldown         = 25f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixWhite",
         pickupIconPath   = "Textures/ItemIcons/texAffixWhiteIcon",
         nameToken        = "EQUIPMENT_AFFIXWHITE_NAME",
         pickupToken      = "EQUIPMENT_AFFIXWHITE_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXWHITE_DESC",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixWhite
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.AffixHaunted, new EquipmentDef
     {
         cooldown         = 10f,
         pickupModelPath  = "Prefabs/PickupModels/PickupAffixHaunted",
         pickupIconPath   = "Textures/ItemIcons/texAffixHauntedIcon",
         nameToken        = "EQUIPMENT_AFFIXHAUNTED_NAME",
         pickupToken      = "EQUIPMENT_AFFIXHAUNTED_PICKUP",
         descriptionToken = "EQUIPMENT_AFFIXHAUNTED_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false,
         passiveBuff      = BuffIndex.AffixHaunted
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.DroneBackup, new EquipmentDef
     {
         cooldown         = 100f,
         pickupModelPath  = "Prefabs/PickupModels/PickupRadio",
         pickupIconPath   = "Textures/ItemIcons/texRadioIcon",
         nameToken        = "EQUIPMENT_DRONEBACKUP_NAME",
         pickupToken      = "EQUIPMENT_DRONEBACKUP_PICKUP",
         descriptionToken = "EQUIPMENT_DRONEBACKUP_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.DroneBackup"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.BFG, new EquipmentDef
     {
         cooldown         = 140f,
         pickupModelPath  = "Prefabs/PickupModels/PickupBFG",
         pickupIconPath   = "Textures/ItemIcons/texBFGIcon",
         nameToken        = "EQUIPMENT_BFG_NAME",
         pickupToken      = "EQUIPMENT_BFG_PICKUP",
         descriptionToken = "EQUIPMENT_BFG_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.BFG"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Enigma, new EquipmentDef
     {
         cooldown         = 60f,
         pickupIconPath   = "Textures/ItemIcons/texEnigmaIcon",
         nameToken        = "EQUIPMENT_ENIGMA_NAME",
         pickupToken      = "EQUIPMENT_ENIGMA_PICKUP",
         descriptionToken = "EQUIPMENT_ENIGMA_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Jetpack, new EquipmentDef
     {
         cooldown         = 60f,
         pickupIconPath   = "Textures/ItemIcons/texChrysalisIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupChrysalis",
         nameToken        = "EQUIPMENT_JETPACK_NAME",
         pickupToken      = "EQUIPMENT_JETPACK_PICKUP",
         descriptionToken = "EQUIPMENT_JETPACK_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Lightning, new EquipmentDef
     {
         cooldown         = 20f,
         pickupIconPath   = "Textures/ItemIcons/texCapacitorIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupCapacitor",
         nameToken        = "EQUIPMENT_LIGHTNING_NAME",
         pickupToken      = "EQUIPMENT_LIGHTNING_PICKUP",
         descriptionToken = "EQUIPMENT_LIGHTNING_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         mageElement      = MageElement.Lightning,
         unlockableName   = "Items.Lightning"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.GoldGat, new EquipmentDef
     {
         cooldown         = 5f,
         pickupIconPath   = "Textures/ItemIcons/texGoldGatIcon",
         pickupModelPath  = "Prefabs/PickupModels/PickupGoldGat",
         nameToken        = "EQUIPMENT_GOLDGAT_NAME",
         pickupToken      = "EQUIPMENT_GOLDGAT_PICKUP",
         descriptionToken = "EQUIPMENT_GOLDGAT_DESC",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = false,
         unlockableName   = "Items.GoldGat"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.PassiveHealing, new EquipmentDef
     {
         cooldown              = 15f,
         pickupIconPath        = "Textures/ItemIcons/texWoodspriteIcon",
         pickupModelPath       = "Prefabs/PickupModels/PickupWoodsprite",
         nameToken             = "EQUIPMENT_PASSIVEHEALING_NAME",
         pickupToken           = "EQUIPMENT_PASSIVEHEALING_PICKUP",
         descriptionToken      = "EQUIPMENT_PASSIVEHEALING_DESC",
         addressToken          = "",
         canDrop               = true,
         enigmaCompatible      = false,
         appearsInSinglePlayer = true,
         unlockableName        = "Items.PassiveHealing"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.LunarPotion, new EquipmentDef
     {
         cooldown         = 5f,
         pickupIconPath   = null,
         pickupModelPath  = null,
         nameToken        = "EQUIPMENT_LUNARPOTION_NAME",
         pickupToken      = "EQUIPMENT_LUNARPOTION_NAME",
         descriptionToken = "EQUIPMENT_LUNARPOTION_DESC",
         addressToken     = "",
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.BurnNearby, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupPotion",
         pickupIconPath   = "Textures/ItemIcons/texPotionIcon",
         nameToken        = "EQUIPMENT_BURNNEARBY_NAME",
         pickupToken      = "EQUIPMENT_BURNNEARBY_PICKUP",
         descriptionToken = "EQUIPMENT_BURNNEARBY_DESC",
         unlockableName   = "Items.BurnNearby",
         addressToken     = "",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.SoulCorruptor, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = null,
         pickupIconPath   = null,
         canDrop          = false,
         enigmaCompatible = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Scanner, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupScanner",
         pickupIconPath   = "Textures/ItemIcons/texScannerIcon",
         canDrop          = true,
         enigmaCompatible = true,
         unlockableName   = "Items.Scanner"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.CrippleWard, new EquipmentDef
     {
         cooldown         = 15f,
         pickupModelPath  = "Prefabs/PickupModels/PickupEffigy",
         pickupIconPath   = "Textures/ItemIcons/texEffigyIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Gateway, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupVase",
         pickupIconPath   = "Textures/ItemIcons/texVaseIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = false,
         unlockableName   = "Items.Gateway"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Tonic, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupTonic",
         pickupIconPath   = "Textures/ItemIcons/texTonicIcon",
         canDrop          = true,
         enigmaCompatible = false,
         isLunar          = true,
         colorIndex       = ColorCatalog.ColorIndex.LunarItem,
         unlockableName   = "Items.Tonic"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.QuestVolatileBattery, new EquipmentDef
     {
         cooldown         = 60f,
         pickupModelPath  = "Prefabs/PickupModels/PickupBatteryArray",
         pickupIconPath   = "Textures/ItemIcons/texBatteryArrayIcon",
         canDrop          = false,
         enigmaCompatible = false,
         isLunar          = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.Cleanse, new EquipmentDef
     {
         cooldown         = 20f,
         pickupModelPath  = "Prefabs/PickupModels/PickupWaterPack",
         pickupIconPath   = "Textures/ItemIcons/texWaterPackIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = false,
         unlockableName   = "Items.Cleanse"
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.FireBallDash, new EquipmentDef
     {
         cooldown         = 30f,
         pickupModelPath  = "Prefabs/PickupModels/PickupEgg",
         pickupIconPath   = "Textures/ItemIcons/texEggIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = false
     });
     EquipmentCatalog.RegisterEquipment(EquipmentIndex.GainArmor, new EquipmentDef
     {
         cooldown         = 45f,
         pickupModelPath  = "Prefabs/PickupModels/PickupElephantFigure",
         pickupIconPath   = "Textures/ItemIcons/texElephantFigureIcon",
         canDrop          = true,
         enigmaCompatible = true,
         isLunar          = false
     });
     for (EquipmentIndex equipmentIndex = EquipmentIndex.CommandMissile; equipmentIndex < EquipmentIndex.Count; equipmentIndex++)
     {
         if (EquipmentCatalog.GetEquipmentDef(equipmentIndex) == null)
         {
             Debug.LogErrorFormat("Equipment {0} is unregistered!", new object[]
             {
                 equipmentIndex
             });
         }
     }
     EquipmentCatalog.modHelper.CollectAndRegisterAdditionalEntries(ref EquipmentCatalog.equipmentDefs);
     EquipmentCatalog.equipmentCount = EquipmentCatalog.equipmentDefs.Length;
     EquipmentCatalog.availability.MakeAvailable();
 }