Exemple #1
0
        public static void OnGrantItem()
        {
            On.RoR2.GenericPickupController.GrantItem += (orig, self, body, inventory) =>
            {
                // Item to share
                var item = self.pickupIndex.itemIndex;

                if (!ShareSuite.GetItemBlackList().Contains((int)item) &&
                    NetworkServer.active &&
                    IsValidPickup(self.pickupIndex) &&
                    IsMultiplayer() &&
                    ShareSuite.ModIsEnabled.Value)
                {
                    foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master))
                    {
                        // Ensure character is not original player that picked up item
                        if (player.inventory == inventory)
                        {
                            continue;
                        }
                        if (!player.alive && !ShareSuite.DeadPlayersGetItems.Value)
                        {
                            continue;
                        }
                        player.inventory.GiveItem(item);
                        _sendPickup = false;
                        SendPickupMessage.Invoke(null, new object[] { player, self.pickupIndex });
                        _sendPickup = true;
                    }
                }

                orig(self, body, inventory);
            };
        }
        private static void InitSettings()
        {
            //Build list of settings that can be controlled in the UI
            _availableSettings = new List <object>();

            _availableSettings.Add(ShareSuite.MoneyIsShared);
            _availableSettings.Add(ShareSuite.WhiteItemsShared);
            _availableSettings.Add(ShareSuite.GreenItemsShared);
            _availableSettings.Add(ShareSuite.RedItemsShared);
            _availableSettings.Add(ShareSuite.EquipmentShared);
            _availableSettings.Add(ShareSuite.LunarItemsShared);
            _availableSettings.Add(ShareSuite.BossItemsShared);
            _availableSettings.Add(ShareSuite.QueensGlandsShared);
            _availableSettings.Add(ShareSuite.PrinterCauldronFixEnabled);
            _availableSettings.Add(ShareSuite.DeadPlayersGetItems);
            _availableSettings.Add(ShareSuite.OverridePlayerScalingEnabled);
            _availableSettings.Add(ShareSuite.InteractablesCredit);
            _availableSettings.Add(ShareSuite.OverrideBossLootScalingEnabled);
            _availableSettings.Add(ShareSuite.BossLootCredit);
            _availableSettings.Add(ShareSuite.MoneyScalarEnabled);
            _availableSettings.Add(ShareSuite.MoneyScalar);
            _availableSettings.Add(ShareSuite.ItemBlacklist);
            _availableSettings.Add(ShareSuite.EquipmentBlacklist);

            _bannedItems     = ShareSuite.GetItemBlackList();
            _bannedEquipment = ShareSuite.GetEquipmentBlackList();
        }
        public static void OnGrantEquipment()
        {
            On.RoR2.GenericPickupController.GrantEquipment += (orig, self, body, inventory) =>
            {
                var equip = self.pickupIndex.equipmentIndex;

                if (!ShareSuite.GetEquipmentBlackList().Contains((int)equip) &&
                    NetworkServer.active &&
                    IsValidEquipmentPickup(self.pickupIndex) &&
                    IsMultiplayer() &&
                    ShareSuite.ModIsEnabled.Value)
                {
                    foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master)
                             .Where(p => p.alive || ShareSuite.DeadPlayersGetItems.Value))
                    {
                        SyncToolbotEquip(player, ref equip);

                        // Sync Mul-T Equipment, but perform primary equipment pickup only for clients
                        if (player.inventory == inventory)
                        {
                            continue;
                        }

                        player.inventory.SetEquipmentIndex(equip);
                        self.NetworkpickupIndex = new PickupIndex(player.inventory.currentEquipmentIndex);

                        /*SendPickupMessage.Invoke(inventory.GetComponent<CharacterMaster>(),
                         *  new object[] {player, new PickupIndex(equip)});*/
                    }
                }

                orig(self, body, inventory);
            };
        }
        private static void OnGrantEquipment(On.RoR2.GenericPickupController.orig_GrantEquipment orig, GenericPickupController self, CharacterBody body, Inventory inventory)
        {
            #region Sharedequipment

            var equip = PickupCatalog.GetPickupDef(self.pickupIndex).equipmentIndex;

            if (!ShareSuite.GetEquipmentBlackList().Contains((int)equip) &&
                NetworkServer.active &&
                IsValidEquipmentPickup(self.pickupIndex) &&
                GeneralHooks.IsMultiplayer())
            {
                foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master)
                         .Where(p => p.alive || ShareSuite.DeadPlayersGetItems.Value))
                {
                    SyncToolbotEquip(player, ref equip);

                    // Sync Mul-T Equipment, but perform primary equipment pickup only for clients
                    if (player.inventory == inventory)
                    {
                        continue;
                    }

                    player.inventory.SetEquipmentIndex(equip);
                    self.NetworkpickupIndex = PickupCatalog.FindPickupIndex(equip);
                }
            }

            orig(self, body, inventory);

            #endregion
        }
        private static void OnGrantItem(On.RoR2.GenericPickupController.orig_GrantItem orig, GenericPickupController self, CharacterBody body, Inventory inventory)
        {
            var item    = PickupCatalog.GetPickupDef(self.pickupIndex);
            var itemDef = ItemCatalog.GetItemDef(item.itemIndex);


            if ((ShareSuite.RandomizeSharedPickups.Value || !ShareSuite.GetItemBlackList().Contains((int)item.itemIndex)) &&
                NetworkServer.active &&
                IsValidItemPickup(self.pickupIndex) &&
                GeneralHooks.IsMultiplayer())
            {
                foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master))
                {
                    // Ensure character is not original player that picked up item
                    if (player.inventory == inventory)
                    {
                        continue;
                    }

                    // Do not reward dead players if not required
                    if (!player.alive && !ShareSuite.DeadPlayersGetItems.Value)
                    {
                        continue;
                    }

                    if (ShareSuite.RandomizeSharedPickups.Value)
                    {
                        var giveItem        = GetRandomItemOfTier(itemDef.tier, item.itemIndex);
                        var givePickupIndex = PickupCatalog.FindPickupIndex(giveItem);
                        player.inventory.GiveItem(giveItem);
                        // Alternative: Only show pickup text for yourself
                        // var givePickupDef = PickupCatalog.GetPickupDef(givePickupIndex);
                        // Chat.AddPickupMessage(body, givePickupDef.nameToken, givePickupDef.baseColor, 1);
                        SendPickupMessage(player, givePickupIndex);
                    }
                    // Otherwise give everyone the same item
                    else
                    {
                        player.inventory.GiveItem(item.itemIndex);
                    }
                }
            }

            orig(self, body, inventory);
        }
        public static void OnGrantItem()
        {
            On.RoR2.GenericPickupController.GrantItem += (orig, self, body, inventory) =>
            {
                if (!ShareSuite.ModIsEnabled.Value)
                {
                    orig(self, body, inventory);
                    return;
                }

                // Item to share
                var item = PickupCatalog.GetPickupDef(self.pickupIndex).itemIndex;

                if (!ShareSuite.GetItemBlackList().Contains((int)item) &&
                    NetworkServer.active &&
                    IsValidItemPickup(self.pickupIndex) &&
                    GeneralHooks.IsMultiplayer())
                {
                    foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master))
                    {
                        // Ensure character is not original player that picked up item
                        if (player.inventory == inventory)
                        {
                            continue;
                        }

                        // Do not reward dead players if not required
                        if (!player.alive && !ShareSuite.DeadPlayersGetItems.Value)
                        {
                            continue;
                        }

                        player.inventory.GiveItem(item);
                    }
                }

                orig(self, body, inventory);
            };
        }
Exemple #7
0
        private static void InitSettings()
        {
            //Build list of settings that can be controlled in the UI
            _availableSettings = new List <object>();

            _availableSettings.Add(ShareSuite.WrapMoneyIsShared);
            _availableSettings.Add(ShareSuite.WrapWhiteItemsShared);
            _availableSettings.Add(ShareSuite.WrapGreenItemsShared);
            _availableSettings.Add(ShareSuite.WrapRedItemsShared);
            _availableSettings.Add(ShareSuite.WrapLunarItemsShared);
            _availableSettings.Add(ShareSuite.WrapBossItemsShared);
            _availableSettings.Add(ShareSuite.WrapQueensGlandsShared);
            _availableSettings.Add(ShareSuite.WrapPrinterCauldronFixEnabled);
            _availableSettings.Add(ShareSuite.WrapOverridePlayerScalingEnabled);
            _availableSettings.Add(ShareSuite.WrapOverrideBossLootScalingEnabled);
            _availableSettings.Add(ShareSuite.WrapDeadPlayersGetItems);
            _availableSettings.Add(ShareSuite.WrapMoneyScalar);
            _availableSettings.Add(ShareSuite.WrapInteractablesCredit);
            _availableSettings.Add(ShareSuite.WrapBossLootCredit);
            _availableSettings.Add(ShareSuite.WrapItemBlacklist);

            _bannedItems = ShareSuite.GetItemBlackList();
        }
Exemple #8
0
        private static void OnGrantItem(On.RoR2.GenericPickupController.orig_GrantItem orig,
                                        GenericPickupController self, CharacterBody body, Inventory inventory)
        {
            var item    = PickupCatalog.GetPickupDef(self.pickupIndex);
            var itemDef = ItemCatalog.GetItemDef(item.itemIndex);
            var randomizedPlayerDict = new Dictionary <CharacterMaster, PickupDef>();

            if ((ShareSuite.RandomizeSharedPickups.Value ||
                 !ShareSuite.GetItemBlackList().Contains((int)item.itemIndex)) &&
                NetworkServer.active &&
                IsValidItemPickup(self.pickupIndex) &&
                GeneralHooks.IsMultiplayer())
            {
                if (ShareSuite.RandomizeSharedPickups.Value)
                {
                    randomizedPlayerDict.Add(body.master, item);
                }

                foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master))
                {
                    // Ensure character is not original player that picked up item
                    if (player.inventory == inventory)
                    {
                        continue;
                    }

                    // Do not reward dead players if not required
                    if (player.IsDeadAndOutOfLivesServer() && !ShareSuite.DeadPlayersGetItems.Value)
                    {
                        continue;
                    }

                    if (ShareSuite.RandomizeSharedPickups.Value)
                    {
                        var itemIsBlacklisted = true;
                        var giveItem          = PickupCatalog.GetPickupDef(GetRandomItemOfTier(itemDef.tier, item.pickupIndex));
                        while (itemIsBlacklisted)
                        {
                            if (ShareSuite.GetItemBlackList().Contains((int)giveItem.itemIndex))
                            {
                                giveItem = PickupCatalog.GetPickupDef(GetRandomItemOfTier(itemDef.tier,
                                                                                          item.pickupIndex));
                            }
                            else
                            {
                                itemIsBlacklisted = false;
                            }
                        }

                        player.inventory.GiveItem(giveItem.itemIndex);
                        // Alternative: Only show pickup text for yourself
                        // var givePickupDef = PickupCatalog.GetPickupDef(givePickupIndex);
                        // Chat.AddPickupMessage(body, givePickupDef.nameToken, givePickupDef.baseColor, 1);

                        // Legacy -- old normal pickup message handler
                        //SendPickupMessage(player, giveItem);

                        randomizedPlayerDict.Add(player, giveItem);
                    }
                    // Otherwise give everyone the same item
                    else
                    {
                        player.inventory.GiveItem(item.itemIndex);
                    }
                }
                ChatHandler.SendRichRandomizedPickupMessage(body.master, item, randomizedPlayerDict);
                orig(self, body, inventory);
                return;
            }

            ChatHandler.SendRichPickupMessage(body.master, item);
            orig(self, body, inventory);
        }