public void OnKilledServer(DamageReport damageReport)
{
Vector3 position = Vector3.zero;
if (damageReport.attackerBody)
{
position = damageReport.victimBody.corePosition;
}
else
{
foreach (var teammate in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
if (teammate.body?.master?.playerCharacterMasterController)
{
position = teammate.body.corePosition;
}
}
}
DropItems(position);
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(equipmentIndex), position, Vector3.up * 20f);
DropCoins(position);
}
static void HandleDropEquipment(NetworkMessage netMsg)
{
var dropEquipment = netMsg.ReadMessage <DropEquipmentPacket>();
var body = dropEquipment.Player.GetComponent <CharacterBody>();
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(dropEquipment.EquipmentIndex), body.transform.position + Vector3.up * 1.5f, Vector3.up * 20f + body.transform.forward * 2f);
}
// This will update the items odds for the interactables that utilize ExplicitPickupDropTable for specific boss items.
private static void UpdateDropTableItemOdds(DropList dropList, ExplicitPickupDropTable dropTable, string interactableName)
{
if (!DropTableItemOdds.ContainsKey(interactableName))
{
DropTableItemOdds.Add(interactableName, new List <float>());
foreach (ExplicitPickupDropTable.Entry entry in dropTable.entries)
{
DropTableItemOdds[interactableName].Add(entry.pickupWeight);
}
}
if (DropTableItemOdds.ContainsKey(interactableName))
{
for (int entryIndex = 0; entryIndex < dropTable.entries.Length; entryIndex++)
{
dropTable.entries[entryIndex].pickupWeight = DropTableItemOdds[interactableName][entryIndex];
}
}
for (int entryIndex = 0; entryIndex < dropTable.entries.Length; entryIndex++)
{
if (!dropList.AvailableBossDropList.Contains(PickupCatalog.FindPickupIndex(dropTable.entries[entryIndex].pickupName)))
{
dropTable.entries[entryIndex].pickupWeight = 0;
}
}
//dropTable.GenerateWeightedSelection();
}
public static void SimulatePickup(CharacterMaster characterMaster, ItemDef itemDef, int amount = 1, bool showNotif = true)
{
var self = characterMaster.inventory;
var pickupIndex = PickupCatalog.FindPickupIndex(itemDef.itemIndex);
//var pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
//var nameToken = pickupDef.nameToken;
//var color = pickupDef.baseColor;
//var body = characterMaster.GetBody();
if (pickupIndex > PickupIndex.none)
{
//Chat.AddPickupMessage(body, nameToken, color, (uint)amount);
Util.PlaySound("Play_UI_item_pickup", characterMaster.GetBodyObject());
self.GiveItem(itemDef, amount);
GenericPickupController.SendPickupMessage(characterMaster, pickupIndex);
if (showNotif)
{
var list = NotificationQueue.instancesList;
list[0].OnPickup(characterMaster, pickupIndex);
/*for (int i = 0; i < list.Count; i++)
* {
* list[i].OnPickup(characterMaster, pickupIndex);
* }*/
}
}
}
private static void DropItemCommand(ConCommandArgs args)
{
var itemName = args.GetArgString(0);
var itemIndex = ItemNameToIndex(itemName);
if (itemIndex == ItemIndex.None)
{
Console.print("Can't find item specified");
return;
}
var count = args.TryGetArgInt(1) ?? 1;
KookehsDropItemMod.Logger.LogDebug("Item index: " + itemIndex);
var master = args.GetSenderMaster();
var inventory = master.inventory;
var charTransform = master.GetBody().GetFieldValue <Transform>("transform");
for (int i = 0; i < count; i++)
{
DropItemHandler.DropItem(charTransform, inventory, PickupCatalog.FindPickupIndex(itemIndex));
}
}
void DropItemIndex(Vector3 position, ItemIndex itemIndex, int count)
{
for (uint i = 0; i < count; i++)
{
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(itemIndex), position, Vector3.up * 5f);
}
}
private bool DropItem(Transform charTransform, Inventory inventory, PickupIndex pickupIndex)
{
_pickups[inventory] = new PickupRecord(Time.time, ItemIndex.None);
//if (!inventory.hasAuthority)
// return false;
var pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
if (pickupDef.equipmentIndex != EquipmentIndex.None)
{
if (inventory.GetEquipmentIndex() != pickupDef.equipmentIndex)
{
return(false);
}
inventory.SetEquipmentIndex(EquipmentIndex.None);
}
else
{
if (inventory.GetItemCount(pickupDef.itemIndex) <= 0)
{
return(false);
}
inventory.RemoveItem(pickupDef.itemIndex, 1);
}
PickupDropletController.CreatePickupDroplet(pickupIndex,
charTransform.position, Vector3.up * 20f + charTransform.forward * 10f);
return(true);
}
void SetOptionsServer(On.RoR2.PickupPickerController.orig_SetOptionsServer orig, RoR2.PickupPickerController pickupPickerController, RoR2.PickupPickerController.Option[] options)
{
List <RoR2.PickupPickerController.Option> optionsAdjusted = new List <PickupPickerController.Option>();
foreach (RoR2.PickupPickerController.Option option in options)
{
if (latestPickupDisplayType == "scrapper")
{
if (playerItems.Contains(PickupCatalog.FindPickupIndex(Catalogue.GetScrapIndex(ItemCatalog.GetItemDef(PickupCatalog.GetPickupDef(option.pickupIndex).itemIndex).tier))))
{
optionsAdjusted.Add(option);
}
}
else if (latestPickupDisplayType == "command")
{
if (playerItems.Contains(option.pickupIndex))
{
optionsAdjusted.Add(option);
}
}
else
{
optionsAdjusted.Add(option);
}
}
options = new RoR2.PickupPickerController.Option[optionsAdjusted.Count];
for (int optionIndex = 0; optionIndex < optionsAdjusted.Count; optionIndex++)
{
options[optionIndex] = optionsAdjusted[optionIndex];
}
orig(pickupPickerController, options);
}
void SetDefaultDropLists(Run run)
{
List <PickupIndex> masterList = new List <PickupIndex>();
foreach (PickupIndex pickupIndex in run.availableTier1DropList)
{
masterList.Add(pickupIndex);
}
foreach (PickupIndex pickupIndex in run.availableTier2DropList)
{
masterList.Add(pickupIndex);
}
foreach (PickupIndex pickupIndex in run.availableTier3DropList)
{
masterList.Add(pickupIndex);
}
foreach (PickupIndex pickupIndex in run.availableBossDropList)
{
masterList.Add(pickupIndex);
}
foreach (PickupIndex pickupIndex in run.availableLunarDropList)
{
masterList.Add(pickupIndex);
}
foreach (PickupIndex pickupIndex in run.availableEquipmentDropList)
{
masterList.Add(pickupIndex);
}
foreach (EquipmentIndex equipmentIndex in Catalogue.eliteEquipment)
{
masterList.Add(PickupCatalog.FindPickupIndex(equipmentIndex));
}
DropList.DuplicateDropList(masterList, playerItems);
DropList.DuplicateDropList(masterList, monsterItems);
}
private static void ScrappingToIdle_OnEnter(On.EntityStates.Scrapper.ScrappingToIdle.orig_OnEnter orig, EntityStates.Scrapper.ScrappingToIdle self)
{
if (!(ShareSuite.PrinterCauldronFixEnabled.Value && NetworkServer.active && GeneralHooks.IsMultiplayer()))
{
orig(self);
return;
}
_itemLock = true;
orig(self);
ScrapperController scrapperController = GetInstanceField(typeof(ScrapperBaseState), self, "scrapperController") as ScrapperController;
Debug.Log(scrapperController);
if (scrapperController)
{
PickupIndex pickupIndex = PickupIndex.none;
ItemDef itemDef = ItemCatalog.GetItemDef(scrapperController.lastScrappedItemIndex);
if (itemDef != null)
{
switch (itemDef.tier)
{
case ItemTier.Tier1:
pickupIndex = PickupCatalog.FindPickupIndex("ItemIndex.ScrapWhite");
break;
case ItemTier.Tier2:
pickupIndex = PickupCatalog.FindPickupIndex("ItemIndex.ScrapGreen");
break;
case ItemTier.Tier3:
pickupIndex = PickupCatalog.FindPickupIndex("ItemIndex.ScrapRed");
break;
case ItemTier.Boss:
pickupIndex = PickupCatalog.FindPickupIndex("ItemIndex.ScrapYellow");
break;
}
}
if (pickupIndex == PickupIndex.none)
{
return;
}
var interactor = GetInstanceField(typeof(ScrapperController), scrapperController, "interactor") as Interactor;
Debug.Log("Interactor Established");
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
if (!interactor)
{
return;
}
CharacterBody component = interactor.GetComponent <CharacterBody>();
component.inventory.GiveItem(pickupDef.itemIndex, scrapperController.itemsEaten);
ChatHandler.SendRichCauldronMessage(component.inventory.GetComponent <CharacterMaster>(), pickupIndex);
}
}
private void Check(TeleporterInteraction teleporterInteraction)
{
if (!hasBeenHit)
{
for (int i = 0; i < CharacterMaster.readOnlyInstancesList.Count; i++)
{
//body.GetComponent<CharacterBody>()?.inventory.GiveItem(catalogIndex);
var player = CharacterMaster.readOnlyInstancesList[i];
if (player)
{
var body = player.GetComponent <CharacterBody>();
if (body)
{
Chat.AddMessage(i.ToString() + "= Gave Master Round to " + player.name);
PickupIndex pickupIndex = PickupCatalog.FindPickupIndex(catalogIndex);
Vector3 pickupVelocity = new Vector3(100 * i, 100, 100 * i);
PickupDropletController.CreatePickupDroplet(pickupIndex, teleporterInteraction.transform.position, pickupVelocity);
}
}
}
}
else
{
Chat.AddMessage("Players didn't survive the hits");
}
}
private void MaybeAwardLoot(On.RoR2.CharacterBody.orig_OnInventoryChanged orig, CharacterBody self)
{
orig(self);
var amount = self.inventory.GetItemCount(Definition.itemIndex);
if (amount > 0 && amount % 3 == 0)
{
self.inventory.RemoveItem(Definition.itemIndex, 3);
PickupIndex loot;
if (Util.CheckRoll(5, self.master))
{
loot = Run.instance.treasureRng.NextElementUniform(Run.instance.availableTier3DropList);
}
else
{
loot = Run.instance.treasureRng.NextElementUniform(Run.instance.availableTier2DropList);
}
if (self.isPlayerControlled)
{
PickupDropletController.CreatePickupDroplet(loot, self.corePosition, Vector3.up * 5);
}
else
{
PickupDef def = PickupCatalog.GetPickupDef(loot);
self.inventory.GiveItem(def.itemIndex);
var lootCount = self.inventory.GetItemCount(def.itemIndex);
Chat.AddPickupMessage(self, def.nameToken, ColorCatalog.GetColor(ItemCatalog.GetItemDef(def.itemIndex).colorIndex), (uint)lootCount);
}
}
}
public void Update()
{
NModLoader.Update();
if (Input.GetKeyDown(KeyCode.F2))
{
//Get the player body to use a position:
var transform = PlayerCharacterMasterController.instances[0].master.GetBodyObject().transform;
//And then drop our defined item in front of the player.
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(NModLoader.LoadedCustomItems[Envy.Name].Index), transform.position, transform.forward * 20f);
}
if (Input.GetKeyDown(KeyCode.F3))
{
//Get the player body to use a position:
var transform = PlayerCharacterMasterController.instances[0].master.GetBodyObject().transform;
var customItems = NModLoader.LoadedCustomItems.Values.ToArray();
for (var i = 0; i < customItems.Length; i++)
{
var rotation = Math.PI * 2 * (i / (float)customItems.Length);
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(customItems[i].Index), transform.position, new Vector3((float)Math.Cos(rotation), 0.05f, (float)Math.Sin(rotation)) * 30f);
}
}
if (Input.GetKeyDown(KeyCode.F4))
{
//Get the player body to use a position:
var transform = PlayerCharacterMasterController.instances[0].master.GetBodyObject().transform;
//And then drop our defined item in front of the player.
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex((ItemIndex)53), transform.position, transform.forward * 20f);
}
}
private void GenericPickupController_GrantItem(On.RoR2.GenericPickupController.orig_GrantItem orig, GenericPickupController self, CharacterBody body, Inventory inventory)
{
orig(self, body, inventory);
PickupDef pickupDef = PickupCatalog.GetPickupDef(self.pickupIndex);
body.master?.GetBodyObject().GetComponent <DropInventoryOnDeath>()?.AddItem((pickupDef != null) ? pickupDef.itemIndex : ItemIndex.None, 1);
}
public static bool PickupIsNonBlacklistedItem(PickupIndex pickupIndex)
{
var pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
var itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
return(itemDef.DoesNotContainTag(ItemTag.AIBlacklist));
}
private void GenericPickupController_AttemptGrant(On.RoR2.GenericPickupController.orig_AttemptGrant orig, GenericPickupController self, CharacterBody body)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.GenericPickupController::AttemptGrant(RoR2.CharacterBody)' called on client");
return;
}
if (!self.gameObject.GetComponent <SpiceRolled>())
{
self.gameObject.AddComponent <SpiceRolled>();
TeamComponent component = body.GetComponent <TeamComponent>();
if (component && component.teamIndex == TeamIndex.Player)
{
Inventory inventory = body.inventory;
if (inventory)
{
var spiceCount = inventory.GetItemCount(SpiceTally);
var spiceCountAdjusted = spiceCount < SpiceEquipment_MaxPerPlayer ? spiceCount : 0;
if (Util.CheckRoll(spiceCountAdjusted))
{
self.pickupIndex = PickupCatalog.FindPickupIndex(Spice.instance.EquipmentDef.equipmentIndex);
}
}
}
}
orig(self, body);
}
void DropLunarCoin(Vector3 position, int count)
{
for (uint i = 0; i < count; i++)
{
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex("LunarCoin.Coin0"), position, Vector3.up * 2f);
}
}
private static void FixScrapperIL(ILContext il)
{
ILCursor c = new ILCursor(il);
c.GotoNext(MoveType.After,
x => x.MatchLdstr("ItemIndex.ScrapYellow"),
x => x.MatchCall(typeof(PickupCatalog), nameof(PickupCatalog.FindPickupIndex)),
x => x.MatchStloc(0)
);
c.Emit(OpCodes.Ldloc_1);
var toLabel = c.Previous;
foreach (var inLabel in c.IncomingLabels)
{
inLabel.Target = toLabel;
}
c.Emit(OpCodes.Ldloc_0);
c.EmitDelegate <Func <ItemDef, PickupIndex, PickupIndex> >((ItemDef item, PickupIndex orig) =>
{
if (item.tier == ItemTier.Lunar)
{
return(PickupCatalog.FindPickupIndex(LunarScrapDef.itemIndex));
}
return(orig);
});
c.Emit(OpCodes.Stloc_0);
}
public void DropRecentItem()
{
if (!NetworkServer.active)
{
var message = new DropRecentItemMessage();
_cmdDropItem.Invoke(message);
}
else
{
var player = PlayerCharacterMasterController.instances[0];
var inventory = player.master.inventory;
if (!_pickups.TryGetValue(inventory, out var pickup))
{
return;
}
if (pickup.ItemIndex == ItemIndex.None || Time.time - pickup.PickupTime > 10)
{
return;
}
// Server, execute command
var characterBody = inventory.GetComponent <CharacterMaster>().GetBody();
var charTransform = characterBody.transform;
var pickupIndex = PickupCatalog.FindPickupIndex(pickup.ItemIndex);
DropItem(charTransform, inventory, pickupIndex);
}
}
private void PodComponent_onRoboPodLandedServer(VehicleSeat actionVehicleSeat, GameObject passenger)
{
if (actionVehicleSeat.rigidbody == vehicleSeat.rigidbody)
{
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(RoR2Content.Equipment.QuestVolatileBattery.equipmentIndex), vehicleSeat.exitPosition.position, Vector3.up);
}
}
private void On_PickupCatalogInit(On.RoR2.PickupCatalog.orig_Init orig)
{
orig();
foreach (CatalogBoilerplate bpl in allInstances)
{
PickupIndex pind;
if (bpl is Equipment)
{
pind = PickupCatalog.FindPickupIndex(((Equipment)bpl).catalogIndex);
}
else if (bpl is Item)
{
pind = PickupCatalog.FindPickupIndex(((Item)bpl).catalogIndex);
}
else
{
continue;
}
var pickup = PickupCatalog.GetPickupDef(pind);
bpl.pickupDef = pickup;
bpl.pickupIndex = pind;
}
}
public void Start()
{
RoR2.EntityLogic.DelayedEvent delayedEvent = GetComponent <RoR2.EntityLogic.DelayedEvent>();
delayedEvent.action = new UnityEvent();
delayedEvent.action.AddListener(() =>
{
AddShrineStack(purchaseInteraction.lastActivator);
});
delayedEvent.timeStepType = RoR2.EntityLogic.DelayedEvent.TimeStepType.FixedTime;
purchaseInteraction = GetComponent <PurchaseInteraction>();
purchaseInteraction.onPurchase.AddListener((interactor) =>
{
purchaseInteraction.SetAvailable(false);
delayedEvent.CallDelayed(1.5f);
});
availableItems = new List <ItemIndex>();
if (NetworkServer.active)
{
rng = new Xoroshiro128Plus(Run.instance.stageRng.nextUlong);
foreach (PickupIndex pickupIndex in Run.instance.availableTier3DropList)
{
availableItems.Add(PickupCatalog.GetPickupDef(pickupIndex).itemIndex);
}
}
}
private RoR2.UI.LogBook.Entry[] On_LogbookBuildPickupEntries(On.RoR2.UI.LogBook.LogBookController.orig_BuildPickupEntries orig)
{
var retv = orig();
Logger.LogDebug("Processing logbook models...");
int replacedModels = 0;
foreach (RoR2.UI.LogBook.Entry e in retv)
{
if (!(e.extraData is PickupIndex))
{
continue;
}
if (e.modelPrefab == null)
{
continue;
}
if (e.modelPrefab.transform.Find("cardfront"))
{
e.modelPrefab = PickupCatalog.GetPickupDef((PickupIndex)e.extraData).displayPrefab;
replacedModels++;
}
}
Logger.LogDebug("Modified " + replacedModels + " logbook models.");
return(retv);
}
private static PickupIndex?GetRandomItemOfTier(ItemTier tier, PickupIndex orDefault)
{
switch (tier)
{
case ItemTier.Tier1:
return(PickRandomOf(Blacklist.AvailableTier1DropList));
case ItemTier.Tier2:
return(PickRandomOf(Blacklist.AvailableTier2DropList));
case ItemTier.Tier3:
return(PickRandomOf(Blacklist.AvailableTier3DropList));
case ItemTier.Lunar:
if (ShareSuite.LunarItemsRandomized.Value)
{
return(PickRandomOf(Blacklist.AvailableLunarDropList));
}
break;
case ItemTier.Boss:
if (ShareSuite.BossItemsRandomized.Value)
{
return(PickRandomOf(Blacklist.AvailableBossDropList));
}
break;
}
var pickupDef = PickupCatalog.GetPickupDef(orDefault);
if (Blacklist.HasItem(pickupDef.itemIndex))
{
return(null);
}
return(orDefault);
}
public static void SendRichCauldronMessage(CharacterMaster player, PickupIndex index)
{
var body = player.hasBody ? player.GetBody() : null;
if (!GeneralHooks.IsMultiplayer() || body == null ||
!ShareSuite.RichMessagesEnabled.Value)
{
SendPickupMessage(player, index);
return;
}
var pickupDef = PickupCatalog.GetPickupDef(index);
var pickupColor = pickupDef.baseColor;
var pickupName = Language.GetString(pickupDef.nameToken);
var playerColor = GetPlayerColor(player.playerCharacterMasterController);
var pickupMessage =
$"<color=#{playerColor}>{body.GetUserName()}</color> <color=#{GrayColor}>traded for</color> " +
$"<color=#{ColorUtility.ToHtmlStringRGB(pickupColor)}>" +
$"{pickupName ?? "???"}</color><color=#{GrayColor}>.</color>";
Chat.SendBroadcastChat(new Chat.SimpleChatMessage {
baseToken = pickupMessage
});
}
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 (!BlackList.HasEquipment(equip) &&
NetworkServer.active &&
IsValidEquipmentPickup(self.pickupIndex) &&
GeneralHooks.IsMultiplayer())
{
foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master)
.Where(p => !p.IsDeadAndOutOfLivesServer() || 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
}
public static PickupSelection ToSelection(this List <EquipmentIndex> indices, float dropChance = 1.0f)
{
return(indices == null ? null : new PickupSelection {
DropChance = dropChance,
Pickups = indices.Select(x => PickupCatalog.FindPickupIndex(x)).ToList()
});
}
public static IEnumerable <PickupIndex> GetDropListForTier(ItemTier itemTier, bool addTierScrap = false)
{
IEnumerable <PickupIndex> HandleWithScrap(IEnumerable <PickupIndex> baseList, ItemDef scrap)
{
return(addTierScrap ? baseList.Append(PickupCatalog.FindPickupIndex(scrap.itemIndex)) : baseList);
}
switch (itemTier)
{
case ItemTier.Tier1:
return(HandleWithScrap(Run.instance.availableTier1DropList, RoR2Content.Items.ScrapWhite));
case ItemTier.Tier2:
return(HandleWithScrap(Run.instance.availableTier2DropList, RoR2Content.Items.ScrapGreen));
case ItemTier.Tier3:
return(HandleWithScrap(Run.instance.availableTier3DropList, RoR2Content.Items.ScrapRed));
case ItemTier.Boss:
return(HandleWithScrap(Run.instance.availableBossDropList, RoR2Content.Items.ScrapYellow));
case ItemTier.Lunar:
return(Run.instance.availableLunarItemDropList);
default:
throw new Exception($"ItemTier {itemTier} has not been handled");
}
}
private static List <PickupIndex> CreateDropList(
IEnumerable <PickupIndex> vanillaDropList,
IEnumerable <EquipmentIndex> equipmentsToAdd,
IEnumerable <EquipmentIndex> equipmentsToRemove)
{
var finalDropList = new List <PickupIndex>();
foreach (var pickupIndex in vanillaDropList)
{
if (!finalDropList.Contains(pickupIndex))
{
finalDropList.Add(pickupIndex);
}
}
foreach (var equipmentIndex in equipmentsToAdd)
{
var pickupIndex = PickupCatalog.FindPickupIndex(equipmentIndex);
if (!finalDropList.Contains(pickupIndex))
{
finalDropList.Add(pickupIndex);
}
}
foreach (var equipmentIndex in equipmentsToRemove)
{
var pickupIndex = PickupCatalog.FindPickupIndex(equipmentIndex);
if (finalDropList.Contains(pickupIndex))
{
finalDropList.Remove(pickupIndex);
}
}
return(finalDropList);
}
internal static void GiveScavsLunarsAndBossItems(On.RoR2.ScavengerItemGranter.orig_Start orig, RoR2.ScavengerItemGranter self)
{
orig(self);
Inventory inventory = self.GetComponent <Inventory>();
if (inventory.GetTotalItemCountOfTier(ItemTier.Lunar) == 0)
{
var list = Run.instance.availableLunarDropList.Where(new System.Func <PickupIndex, bool>(PickupIsNonBlacklistedItem)).ToList();
var randomIndex = Random.Range(0, list.Count);
inventory.GiveItem(PickupCatalog.GetPickupDef(list[randomIndex]).itemIndex, 2);
}
if (inventory.GetTotalItemCountOfTier(ItemTier.Boss) == 0)
{
var list = PickupCatalog.allPickups.Where(def => def.isBoss).ToList();
var randomIndex = Random.Range(0, list.Count);
inventory.GiveItem(list[randomIndex].itemIndex, 1);
}
bool PickupIsNonBlacklistedItem(PickupIndex pickupIndex)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef != null ? pickupDef.itemIndex : ItemIndex.None);
if (itemDef == null)
{
return(false);
}
return(itemDef.DoesNotContainTag(ItemTag.AIBlacklist));
}
}
