private static void Postfix(CharacterBody body, Inventory inventory, GenericPickupController __instance)
{
if (!SetSharedCommand.ItemsShared)
{
return;
}
foreach (PlayerCharacterMasterController playerCharacterMasterController in PlayerCharacterMasterController
.instances)
{
if (!playerCharacterMasterController.master.alive)
{
continue;
}
CharacterBody characterBody = playerCharacterMasterController.master.GetBody();
if (characterBody.Equals(body))
{
return;
}
characterBody.inventory.GiveItem(__instance.pickupIndex.itemIndex);
}
}
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 void GenericPickupController_GrantLunarCoin(On.RoR2.GenericPickupController.orig_GrantLunarCoin orig, GenericPickupController self, CharacterBody body, uint count)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.GenericPickupController::GrantLunarCoin(RoR2.CharacterBody,System.UInt32)' called on client");
return;
}
CharacterMaster master = body.master;
NetworkUser networkUser = Util.LookUpBodyNetworkUser(body);
if (networkUser)
{
if (master)
{
GenericPickupController.SendPickupMessage(master, self.pickupIndex);
}
networkUser.AwardLunarCoins(count);
UnityEngine.Object.Destroy(self.gameObject);
}
else
{
if (master && master.teamIndex != TeamIndex.Player)
{
var component = master.GetBodyObject().GetComponent <DropInventoryOnDeath>();
if (!component)
{
component = master.GetBodyObject().AddComponent <DropInventoryOnDeath>();
}
component.incrementCoins();
GenericPickupController.SendPickupMessage(master, self.pickupIndex);
UnityEngine.Object.Destroy(self.gameObject);
}
}
}
private static void MarkedDropletBypassHook()
{
On.RoR2.PickupDropletController.OnCollisionEnter += (orig, self, collision) =>
{
if (NetworkServer.active && self.alive)
{
if (self.GetComponent <ZetDropMarker>())
{
if (ZetArtifactsPlugin.DropifactBypassGround.Value)
{
self.alive = false;
self.createPickupInfo.position = self.transform.position;
GenericPickupController.CreatePickup(self.createPickupInfo);
UnityEngine.Object.Destroy(self.gameObject);
return;
}
}
}
orig(self, collision);
};
}
// Token: 0x06002C27 RID: 11303 RVA: 0x000BA670 File Offset: 0x000B8870
protected void EnablePickup()
{
ChildLocator component = this.podInfo.podAnimator.GetComponent <ChildLocator>();
if (!component)
{
Debug.Log("Could not find pod child locator.");
return;
}
Transform transform = component.FindChild("BatteryAttachmentPoint");
if (!transform)
{
Debug.Log("Could not find battery attachment point.");
return;
}
Transform transform2 = transform.Find("QuestVolatileBatteryWorldPickup(Clone)");
if (!transform2)
{
Debug.Log("Could not find battery transform");
return;
}
GenericPickupController component2 = transform2.GetComponent <GenericPickupController>();
if (component2)
{
component2.enabled = true;
return;
}
Debug.Log("Could not find pickup controller.");
}
private static void InventoryHook(On.RoR2.GenericPickupController.orig_GrantItem orig,
GenericPickupController self,
CharacterBody body,
Inventory inventory)
{
var networkIdentity = body.master.netId;
var item = PickupCatalog.GetPickupDef(self.pickupIndex);
var itemDef = ItemCatalog.GetItemDef(item.itemIndex);
var itemCount = inventory.GetItemCount(itemDef.itemIndex);
var itemCost = Application.Config.ConfigResolver.ItemCount(itemDef.tier);
var canAdd = itemCount > 1 && itemCount % itemCost == 0;
if (canAdd)
{
var augments = AugmentResolver.ListAugmentsForItem(itemDef.itemIndex);
if (augments != null && augments.Any())
{
AugmentResolver.TryAddOrUpgradeAugmentToPlayer(networkIdentity,
itemDef.itemIndex,
augments.FirstOrDefault().Value.Id);
}
}
orig(self,
body,
inventory);
}
private void GrantItem(On.RoR2.GenericPickupController.orig_GrantItem orig, GenericPickupController self, CharacterBody body, Inventory inventory)
{
orig(self, body, inventory);
if (self && inventory && inventory.GetItemCount(Pillow.itemIndex) > 0)
{
body.AddTimedBuff(BuffIndex.Cloak, 2 * inventory.GetItemCount(Pillow.itemIndex));
}
}
/// <summary>
/// Adds text labels for various interactables to a <see cref="PingIndicator"/>
/// </summary>
/// <param name="pingIndicator">Target <see cref="PingIndicator"/> that should have the text added</param>
private static void AddLootText(RoR2.UI.PingIndicator pingIndicator)
{
const string textStart = "<size=70%>\n";
string price = GetPrice(pingIndicator.pingTarget);
ShopTerminalBehavior shopTerminal = pingIndicator.pingTarget.GetComponent <ShopTerminalBehavior>();
if (shopTerminal && _config.ShowShopText.Value)
{
string text = textStart;
PickupIndex pickupIndex = shopTerminal.CurrentPickupIndex();
PickupDef pickup = PickupCatalog.GetPickupDef(pickupIndex);
text += shopTerminal.pickupIndexIsHidden
? "?"
: $"{Language.GetString(pickup.nameToken)}";
pingIndicator.pingText.text += $"{text} ({price})";
return;
}
GenericPickupController pickupController = pingIndicator.pingTarget.GetComponent <GenericPickupController>();
if (pickupController && _config.ShowPickupText.Value)
{
PickupDef pickup = PickupCatalog.GetPickupDef(pickupController.pickupIndex);
pingIndicator.pingText.text += $"{textStart}{Language.GetString(pickup.nameToken)}";
}
ChestBehavior chest = pingIndicator.pingTarget.GetComponent <ChestBehavior>();
if (chest && _config.ShowChestText.Value)
{
pingIndicator.pingText.text += $"{textStart}{Util.GetBestBodyName(pingIndicator.pingTarget)} ({price})";
return;
}
string name = "";
PurchaseInteraction purchaseInteraction = pingIndicator.pingTarget.GetComponent <PurchaseInteraction>();
if (purchaseInteraction)
{
name = Language.GetString(purchaseInteraction.displayNameToken);
}
// Drones
SummonMasterBehavior summonMaster = pingIndicator.pingTarget.GetComponent <SummonMasterBehavior>();
if (summonMaster && _config.ShowDroneText.Value)
{
pingIndicator.pingText.text += $"{textStart}{name} ({price})";
return;
}
if (_config.ShowShrineText.Value)
{
pingIndicator.pingText.text += $"{textStart}{name}";
}
}
/// <summary>
/// Method to get the interactable tier color from a ping target
/// </summary>
/// <param name="gameObject">The ping target</param>
/// <returns>An Color instance of the tier color</returns>
private Color GetTargetTierColor(GameObject gameObject)
{
Color color = Color.black;
ShopTerminalBehavior shopTerminal = gameObject.GetComponent <ShopTerminalBehavior>();
if (shopTerminal)
{
PickupIndex pickupIndex = shopTerminal.CurrentPickupIndex();
PickupDef pickup = PickupCatalog.GetPickupDef(pickupIndex);
if (pickup != null)
{
color = pickup.baseColor;
}
}
GenericPickupController pickupController = gameObject.GetComponent <GenericPickupController>();
if (pickupController)
{
PickupDef pickup = PickupCatalog.GetPickupDef(pickupController.pickupIndex);
if (pickup != null)
{
color = pickup.baseColor;
}
}
PurchaseInteraction purchaseInteraction = gameObject.GetComponent <PurchaseInteraction>();
if (purchaseInteraction)
{
CostTypeDef costType = CostTypeCatalog.GetCostTypeDef(purchaseInteraction.costType);
color = ColorCatalog.GetColor(costType.colorIndex);
}
PickupIndexNetworker pickupIndexNetworker = gameObject.GetComponent <PickupIndexNetworker>();
if (pickupIndexNetworker)
{
PickupDef pickup = PickupCatalog.GetPickupDef(pickupIndexNetworker.NetworkpickupIndex);
if (pickup != null)
{
color = pickup.baseColor;
}
}
if (color == Color.black)
{
color = _colors["InteractablePingColor"];
}
return(color);
}
public bool TryConsumeItemPingedByUser(NetworkUser user, GenericPickupController pickupController)
{
if (CheckIfItemPingedByUser(user, pickupController))
{
watchedPingedItems.Remove(user.id);
return(true);
}
return(false);
}
static bool Prefix(GenericPickupController __instance, bool value)
{
var toggle = Precipitation.RainServer.GetToggle("infinite_recycling");
if (toggle)
{
Logger.Debug("Prevented recycler from setting!");
}
return(!toggle);
}
public void Awake()
{
if (effects)
{
initialLightIntensity = effects.GetComponentInChildren <Light>().intensity;
ParticleSystemRenderer particleSystemRenderer = effects.GetComponentInChildren <ParticleSystemRenderer>();
initialColor = particleSystemRenderer.material.GetColor("_TintColor");
}
genericPickupController = GetComponent <GenericPickupController>();
materialPropertyBlock = new MaterialPropertyBlock();
}
public void PickupItems()
{
if (!master.inventory)
{
return;
}
List <GenericPickupController> pickups = InstanceTracker.GetInstancesList <GenericPickupController>();
for (int i = 0; i < pickups.Count; i++)
{
GenericPickupController pickup = pickups[i];
// Skip lunar coins
if (PickupCatalog.GetPickupDef(pickup.pickupIndex).coinValue > 0)
{
continue;
}
// Skip these
ItemDef def = ItemCatalog.GetItemDef(PickupCatalog.GetPickupDef(pickup.pickupIndex).itemIndex);
if (def != null && def.tier == ItemTier.Lunar)
{
continue;
}
EquipmentIndex equipmentIndex = PickupCatalog.GetPickupDef(pickup.pickupIndex).equipmentIndex;
if (equipmentIndex != EquipmentIndex.None)
{
if (EquipmentCatalog.GetEquipmentDef(equipmentIndex).isLunar)
{
continue;
}
if (master.inventory.currentEquipmentIndex != EquipmentIndex.None)
{
continue;
}
}
if (pickup.GetInteractability(this.bodyInteractor) == Interactability.Available)
{
// Move to pickup item if within 60 meters
float dist = PlayerBotUtils.GetFastDist(master.GetBody().transform.position, pickup.gameObject.transform.position);
if (dist <= (60f * 60f))
{
this.ai.customTarget.gameObject = pickup.gameObject;
return;
}
}
}
}
private void Conditional_ForceEquipmentUse(On.RoR2.CharacterAI.BaseAI.orig_UpdateBodyInputs orig, BaseAI self)
{
var component = self.gameObject.GetComponent <BEDUComponent>();
if (component)
{
BaseAIState baseAIState;
if ((baseAIState = (self.stateMachine.state as BaseAIState)) != null)
{
self.bodyInputs = baseAIState.GenerateBodyInputs(self.bodyInputs);
}
if (self.bodyInputBank)
{
bool freeUseEquipment = component.freeUse && self.bodyInputs.pressActivateEquipment;
bool useEquipment = component.useEquipment || freeUseEquipment;
bool shouldJump = component.droneMode == DroneMode.Evade ? component.shouldJump : self.bodyInputs.pressJump;
self.bodyInputBank.skill1.PushState(self.bodyInputs.pressSkill1);
self.bodyInputBank.skill2.PushState(self.bodyInputs.pressSkill2);
self.bodyInputBank.skill3.PushState(self.bodyInputs.pressSkill3);
self.bodyInputBank.skill4.PushState(self.bodyInputs.pressSkill4);
self.bodyInputBank.jump.PushState(shouldJump);
self.bodyInputBank.sprint.PushState(true); //self.bodyInputs.pressSprint
component.shouldJump = false;
if (component.droneMode == DroneMode.Recycle)
{
GenericPickupController pickupController = self.body.equipmentSlot.currentTarget.pickupController;
if (pickupController && !pickupController.Recycled)
{
//_logger.LogMessage($"Equipment Drone is currently looking at {PickupCatalog.GetPickupDef(pickupController.pickupIndex).internalName}");
PickupIndex initialPickupIndex = pickupController.pickupIndex;
if (allowedPickupIndices.Contains(initialPickupIndex))
{
useEquipment = true;
}
}
}
self.bodyInputBank.activateEquipment.PushState(useEquipment);
self.bodyInputBank.moveVector = self.bodyInputs.moveVector;
}
}
else
{
orig(self);
}
}
private static void DropAllOtherSharedEquipment(GenericPickupController self, CharacterBody body,
EquipmentIndex originalEquip)
{
var droppedEquipment = new List <EquipmentIndex>();
foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master)
.Where(p => p.inventory && p != body.master))
{
var playerEquipment = player.inventory.GetEquipmentIndex();
if (!EquipmentShared(playerEquipment) || droppedEquipment.Contains(playerEquipment) ||
playerEquipment == originalEquip)
{
continue;
}
CreateDropletIfExists(GetPickupIndex(playerEquipment), self.transform.position);
droppedEquipment.Add(playerEquipment);
}
}
// Token: 0x0600048E RID: 1166 RVA: 0x00013078 File Offset: 0x00011278
public override void FixedUpdate()
{
base.FixedUpdate();
if (base.fixedAge >= Opening.delayUntilUnlockAchievement && !this.hasGrantedAchievement)
{
Action action = Opening.onOpened;
if (action != null)
{
action();
}
this.hasGrantedAchievement = true;
GenericPickupController componentInChildren = base.gameObject.GetComponentInChildren <GenericPickupController>();
if (componentInChildren)
{
componentInChildren.enabled = true;
}
}
}
private void GenericPickupController_OnTriggerStay(On.RoR2.GenericPickupController.orig_OnTriggerStay orig, GenericPickupController self, Collider other)
{
if (!ArtifactEnabled)
{
orig(self, other);
return;
}
if (NetworkServer.active && self.waitStartTime.timeSince >= self.waitDuration && !self.consumed)
{
CharacterBody component = other.GetComponent <CharacterBody>();
if (component)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(self.pickupIndex);
ItemIndex itemIndex = (pickupDef != null) ? pickupDef.itemIndex : ItemIndex.None;
if (itemIndex != ItemIndex.None && ItemCatalog.GetItemDef(itemIndex).tier == ItemTier.Lunar && component.isPlayerControlled)
{
return;
}
EquipmentIndex equipmentIndex = (pickupDef != null) ? pickupDef.equipmentIndex : EquipmentIndex.None;
if (equipmentIndex != EquipmentIndex.None)
{
if (EquipmentCatalog.GetEquipmentDef(equipmentIndex).isLunar)
{
return;
}
if (component.inventory && component.inventory.currentEquipmentIndex != EquipmentIndex.None)
{
return;
}
}
if (pickupDef != null && pickupDef.coinValue != 0U && component.isPlayerControlled)
{
return;
}
if (GenericPickupController.BodyHasPickupPermission(component))
{
self.AttemptGrant(component);
}
}
}
}
public void SetUnlockedItemNotification(RoR2.UI.PingIndicator pingIndicator)
{
GenericPickupController pickupController = pingIndicator.pingTarget.GetComponent <GenericPickupController>();
if (pickupController && _config.ShowItemNotification.Value)
{
BuildNotification(pickupController.pickupIndex, pingIndicator);
}
PurchaseInteraction purchaseInteraction = pingIndicator.pingTarget.GetComponent <PurchaseInteraction>();
if (purchaseInteraction && _config.ShowItemNotification.Value)
{
ShopTerminalBehavior shopTerminalBehavior = purchaseInteraction.GetComponent <ShopTerminalBehavior>();
if (shopTerminalBehavior && !shopTerminalBehavior.pickupIndexIsHidden)
{
BuildNotification(shopTerminalBehavior.CurrentPickupIndex(), pingIndicator);
}
}
}
private void OnGrantItem(
On.RoR2.GenericPickupController.orig_GrantItem orig,
GenericPickupController self,
CharacterBody body,
Inventory inventory
)
{
GrantItem = orig;
genericPickupController = self;
ItemIndex itemIndex = PickupCatalog.GetPickupDef(self.pickupIndex).itemIndex;
if (PreventPickupConfigEntries.ContainsKey(itemIndex) && PreventPickupConfigEntries[itemIndex].Value)
{
GiveRandomItem(body, inventory, itemIndex);
return;
}
orig.Invoke(self, body, inventory);
}
private void PreventBulletAutoPickup(On.RoR2.GenericPickupController.orig_OnTriggerStay orig, GenericPickupController self, Collider other)
{
if (self.pickupIndex != PickupCatalog.FindPickupIndex(PastKillingBullet.instance.ItemDef.itemIndex))
{
orig(self, other);
}
else
{
orig(self, null);
}
}
private static void OnGrantEquipment(On.RoR2.GenericPickupController.orig_GrantEquipment orig,
GenericPickupController self, CharacterBody body, Inventory inventory)
{
#region Sharedequipment
if (!ShareSuite.EquipmentShared.Value || !GeneralHooks.IsMultiplayer() || !NetworkServer.active)
{
orig(self, body, inventory);
return;
}
// Get the old and new equipment's index
var oldEquip = body.inventory.currentEquipmentIndex;
var oldEquipPickupIndex = GetPickupIndex(oldEquip);
var newEquip = PickupCatalog.GetPickupDef(self.pickupIndex).equipmentIndex;
// Send the pickup message
ChatHandler.SendPickupMessage(body.master, self.pickupIndex);
// Give the equipment to the picker
inventory.SetEquipmentIndex(newEquip);
// Destroy the object
Object.Destroy(self.gameObject);
// If the old equipment was not shared and the new one is, drop the blacklisted equipment and any other
// shared equipment that the other players have
if (!EquipmentShared(oldEquip) && EquipmentShared(newEquip))
{
CreateDropletIfExists(oldEquipPickupIndex, self.transform.position);
DropAllOtherSharedEquipment(self, body, oldEquip);
}
// If the old equipment was shared and the new one isn't, but the picker is the only one alive with the
// shared equipment, drop it on the ground and return
else if (EquipmentShared(oldEquip) && !EquipmentShared(newEquip) && GetLivingPlayersWithEquipment(oldEquip) < 1 ||
!EquipmentShared(oldEquip) && !EquipmentShared(newEquip))
{
CreateDropletIfExists(oldEquipPickupIndex, self.transform.position);
return;
}
// If the new equip is shared, create a droplet of the old one.
else if (EquipmentShared(newEquip))
{
CreateDropletIfExists(oldEquipPickupIndex, self.transform.position);
}
// If the equipment they're picking up is not shared and someone else is alive with the shared equipment,
// return
else
{
return;
}
// Loop over everyone who has an inventory and isn't the picker
foreach (var player in PlayerCharacterMasterController.instances.Select(p => p.master)
.Where(p => p.inventory && p != body.master))
{
var playerInventory = player.inventory;
var playerOrigEquipment = playerInventory.currentEquipmentIndex;
// If the player currently has an equipment that's blacklisted
if (!EquipmentShared(playerOrigEquipment))
{
// And the config option is set so that they will drop the item when shared
if (!ShareSuite.DropBlacklistedEquipmentOnShare.Value)
{
continue;
}
// Create a droplet of their current blacklisted equipment on the ground
var transform = player.GetBodyObject().transform;
var pickupIndex = PickupCatalog.FindPickupIndex(playerOrigEquipment);
PickupDropletController.CreatePickupDroplet(pickupIndex, transform.position,
transform.forward * 20f);
}
// Give the player the new equipment
playerInventory.SetEquipmentIndex(newEquip);
self.NetworkpickupIndex = PickupCatalog.FindPickupIndex(newEquip);
// Sync the equipment if they're playing MUL-T
SyncToolbotEquip(player, ref newEquip);
}
#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);
}
private void GenericPickupController_GrantEquipment(On.RoR2.GenericPickupController.orig_GrantEquipment orig, GenericPickupController self, CharacterBody body, Inventory inventory)
{
orig(self, body, inventory);
LastPickedUpItem[inventory] = PickupCatalog.FindPickupIndex(inventory.GetEquipmentIndex());
}
private void GenericPickupController_GrantItem(On.RoR2.GenericPickupController.orig_GrantItem orig, GenericPickupController self, CharacterBody body, Inventory inventory)
{
orig(self, body, inventory);
var pickupDef = PickupCatalog.GetPickupDef(self.pickupIndex);
if (pickupDef != null)
{
var itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
if (itemDef != null && itemDef.tier != ItemTier.NoTier)
{
LastPickedUpItem[inventory] = pickupDef.pickupIndex;
}
}
}
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
}
private void GenericPickupController_OnTriggerStay(On.RoR2.GenericPickupController.orig_OnTriggerStay orig, GenericPickupController self, Collider other)
{
if (NetworkServer.active)
{
if (other)
{
bool result = true;
var character = other.GetComponent <CharacterBody>();
if (character)
{
if (self != null && self.pickupIndex != null)
{
var charactername = character.baseNameToken;
dropping.TryGetValue(self.pickupIndex.itemIndex, out Dictionary <string, bool> characterdic);
if (characterdic != null)
{
characterdic.TryGetValue(charactername, out result);
}
}
}
if (result)
{
orig(self, other);
}
}
}
}
internal string GenericPickupController_GetContextString(On.RoR2.GenericPickupController.orig_GetContextString orig, GenericPickupController self, Interactor activator)
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(self.pickupIndex);
string pickupText = string.Format(Language.GetString(((pickupDef != null) ? pickupDef.interactContextToken : null) ?? string.Empty), Language.GetString(pickupDef.nameToken));
if (pickupDef.itemIndex != ItemIndex.None)
{
ItemDef itemDef = ItemCatalog.GetItemDef(pickupDef.itemIndex);
pickupText += $"\n\n{Language.GetString( mod.config.MiscPickupDescriptionAdvanced.Value ? itemDef.descriptionToken : itemDef.pickupToken)}";
}
else if (pickupDef.equipmentIndex != EquipmentIndex.None)
{
EquipmentDef equipmentDef = EquipmentCatalog.GetEquipmentDef(pickupDef.equipmentIndex);
pickupText += $"\n\n{Language.GetString(mod.config.MiscPickupDescriptionAdvanced.Value ? equipmentDef.descriptionToken : equipmentDef.pickupToken)}";
}
return(pickupText);
}
private bool GenericPickupController_OnSerialize(On.RoR2.GenericPickupController.orig_OnSerialize orig, GenericPickupController self, NetworkWriter writer, bool forceAll)
{
if (NetworkServer.active)
{
if (isCurrentStageBazaar())
{
List <BazaarItem> bazaarItems = bazaar.GetBazaarItems();
for (int i = 0; i < bazaarItems.Count; i++)
{
if (bazaarItems[i].genericPickupController == self)
{
if (forceAll)
{
GeneratedNetworkCode._WritePickupIndex_None(writer, bazaarItems[i].pickupIndex);
writer.Write(self.Recycled);
return(true);
}
bool flag = false;
if ((self.GetComponent <NetworkBehaviour>().GetFieldValue <uint>("m_SyncVarDirtyBits") & 1u) != 0u)
{
if (!flag)
{
writer.WritePackedUInt32(self.GetComponent <NetworkBehaviour>().GetFieldValue <uint>("m_SyncVarDirtyBits"));
flag = true;
}
GeneratedNetworkCode._WritePickupIndex_None(writer, bazaarItems[i].pickupIndex);
}
if ((self.GetComponent <NetworkBehaviour>().GetFieldValue <uint>("m_SyncVarDirtyBits") & 2u) != 0u)
{
if (!flag)
{
writer.WritePackedUInt32(self.GetComponent <NetworkBehaviour>().GetFieldValue <uint>("m_SyncVarDirtyBits"));
flag = true;
}
writer.Write(self.Recycled);
}
if (!flag)
{
writer.WritePackedUInt32(self.GetComponent <NetworkBehaviour>().GetFieldValue <uint>("m_SyncVarDirtyBits"));
}
return(flag);
}
}
}
}
return(orig(self, writer, forceAll));
}
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 ||
!BlackList.HasItem(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 (!ShareSuite.DeadPlayersGetItems.Value && player.IsDeadAndOutOfLivesServer())
{
continue;
}
if (ShareSuite.RandomizeSharedPickups.Value)
{
var pickupIndex = GetRandomItemOfTier(itemDef.tier, item.pickupIndex);
if (pickupIndex == null)
{
// Could not find any not blacklisted item in that tier. You get nothing! Good day, sir!
continue;
}
var giveItem = PickupCatalog.GetPickupDef(pickupIndex.Value);
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);
}
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);
}
