public static void updateInventory(Inventory inventory, CharacterMaster master)
{
if (!Tier1Items.Value)
{
foreach (ItemIndex index in ItemCatalog.tier1ItemList)
{
inventory.ResetItem(index);
}
}
if (!Tier2Items.Value)
{
foreach (ItemIndex index in ItemCatalog.tier2ItemList)
{
inventory.ResetItem(index);
}
}
if (!Tier3Items.Value)
{
foreach (ItemIndex index in ItemCatalog.tier3ItemList)
{
inventory.ResetItem(index);
}
}
if (!LunarItems.Value)
{
foreach (ItemIndex index in ItemCatalog.lunarItemList)
{
inventory.ResetItem(index);
}
}
inventory.CopyItemsFrom(master.inventory);
multiplier(inventory);
if (EquipItems.Value)
{
inventory.ResetItem(RoR2Content.Items.AutoCastEquipment);
inventory.GiveItem(RoR2Content.Items.AutoCastEquipment, 1);
inventory.CopyEquipmentFrom(master.inventory);
foreach (EquipmentDef item in EquipmentBlacklist)
{
if (inventory.GetEquipmentIndex() == item.equipmentIndex)
{
inventory.SetEquipmentIndex(RoR2Content.Equipment.QuestVolatileBattery.equipmentIndex); // default to Fuel Array
break;
}
}
}
blacklist(inventory);
}
// needs to be able to be sent by clients so they can drop custom money amounts
// dunno if this just does that tho
/*[ConCommand(commandName = "dropmoney", flags = ConVarFlags.ExecuteOnServer, helpText = "dropmoney {amount}.")]
* private static void CMDDropMoney(ConCommandArgs args)
* {
* var amountOverride = args.Count > 0 ? args.GetArgInt(0) : -1;
*
* ReleaseMoney(args.senderMaster.playerCharacterMasterController, amountOverride);
* }*/
// Server Method
public static void ReleaseMoney(CharacterMaster master, int doshesDropped = 1)
{
if (!NetworkServer.active)
{
return;
}
uint goldReward = (uint)Mathf.CeilToInt(Run.instance.GetDifficultyScaledCost(baseChestCost) * percentToDrop * doshesDropped);
if (master && master.GetBody())
{
// 15 - 25 = -10, so resulting money is 10 to drop
if (goldReward > master.money)
{
goldReward = master.money;
}
//goldReward <= 0 or goldReward < 1??
if ((uint)goldReward <= 0)
{
//to avoid dropping $0 items.
return;
}
GameObject pickup = Instantiate(ShareMoneyPack);
pickup.transform.position = master.GetBody().corePosition;
ModifiedMoneyPickup moneyPickup = pickup.GetComponentInChildren <ModifiedMoneyPickup>();
moneyPickup.goldReward = (int)goldReward;
moneyPickup.owner = master.GetBody() ?? null;
Rigidbody component = pickup.GetComponent <Rigidbody>();
Vector3 direction;
if (master.GetBody().inputBank)
{
Ray aimRay = master.GetBody().inputBank.GetAimRay();
direction = aimRay.direction;
pickup.transform.position = aimRay.origin; //set position to aimray if aimray is found
}
else
{
direction = master.GetBody().transform.forward;
}
component.velocity = Vector3.up * 5f + (direction * 20f); // please fine tune
// Figure out how to communicate to the client how much money was dropped.
//Chat.AddMessage($"You have dropped ${(uint)goldReward}");
//DamageNumberManager.instance.SpawnDamageNumber((int)goldReward, pickup.transform.position, false, TeamIndex.Player, DamageColorIndex.Item);
NetworkServer.Spawn(pickup);
master.money = (uint)(Mathf.Max(0f, master.money - goldReward));
}
}
private void RunStart(RoR2.Run run)
{
// Init Item Event
CharacterMaster clientMaster = PlayerCharacterMasterController.instances[0].master;
clientMaster.inventory.onInventoryChanged += () =>
{
int numDriftItems = clientMaster.inventory.GetItemCount(driftItemDef.itemIndex);
int deltaItems = numDriftItems - clientNumDriftItems;
clientMaster.playerCharacterMasterController.networkUser.GetCurrentBody().sprintingSpeedMultiplier += (deltaItems * .1f);
};
}
public override void Effect(GlobalEventManager globalEventManager, DamageInfo damageInfo, GameObject victim, int itemCount)
{
CharacterBody body = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody Attacker = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody characterBody = victim ? victim.GetComponent <CharacterBody>() : null;
CharacterMaster master = Attacker.master;
Inventory inventory = master.inventory;
TeamComponent Team = Attacker.GetComponent <TeamComponent>();
TeamIndex attackerTeamIndex = Team ? Team.teamIndex : TeamIndex.Neutral;
Vector3 aimOrigin = Attacker.aimOrigin;
characterBody.AddTimedBuff(BuffIndex.Slow60, 1f * itemCount);
}
private bool IsPrototypeCountUncapped(CharacterMaster master)
{
int prototypeNumber = 0;
master.LoopMinions(minion =>
{
if (minion.name.Contains("MegaDroneMaster"))
{
prototypeNumber++;
}
});
return(prototypeNumber < maxPrototypePlayerCount);
}
public void Awake()
{
this.master = base.gameObject.GetComponent <CharacterMaster>();
this.maxPurchases = PlayerBotManager.MaxBotPurchasesPerStage.Value;
this.chestPicker = new WeightedSelection <ChestTier>();
this.chestPicker.AddChoice(ChestTier.WHITE, PlayerBotManager.Tier1ChestBotWeight.Value);
this.chestPicker.AddChoice(ChestTier.GREEN, PlayerBotManager.Tier2ChestBotWeight.Value);
this.chestPicker.AddChoice(ChestTier.RED, PlayerBotManager.Tier3ChestBotWeight.Value);
ResetPurchases();
ResetBuyingDelay();
}
private static void CCGod(ConCommandArgs args)
{
if (args.senderMasterObject)
{
CharacterMaster component = args.senderMasterObject.GetComponent <CharacterMaster>();
if (component)
{
bool god = (bool)component.GetType().GetField("godMode", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(component);
component.GetType().GetField("godMode", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(component, !god);
component.GetBody().healthComponent.godMode = god;
}
}
}
public static void CCSpawnGeneral(ConCommandArgs args)
{
args.CheckArgumentCount(2);
CharacterMaster master = args.senderMasterObject.GetComponent <CharacterMaster>();
TeamIndex team = master.teamIndex;
if (args.Count >= 3)
{
Enum.TryParse(args[2], true, out team);
}
SpawnMasterWithBody(args[0], args[1], master.GetBody().transform.position, team, master.inventory);
}
public void GetObject()
{
//---------------------------------------------------------------------\\
Pcontroller = FindObjectOfType <PlayerCharacterMasterController>();
Cbody = FindObjectOfType <CharacterBody>();
Cmaster = FindObjectOfType <CharacterMaster>();
Pinteraction = FindObjectOfType <PurchaseInteraction>();
Tmanager = FindObjectOfType <TeamManager>();
Cmotor = FindObjectOfType <CharacterMotor>();
Pinterobj = UnityEngine.Object.FindObjectsOfType(typeof(PurchaseInteraction));
Tinterobj = UnityEngine.Object.FindObjectsOfType(typeof(TeleporterInteraction));
//---------------------------------------------------------------------\\
}
public void Awake()
{
this.master = base.GetComponent <CharacterMaster>();
this.ai = base.GetComponent <BaseAI>();
this.stateMachine = base.GetComponent <EntityStateMachine>();
if (ai is PlayerBotBaseAI)
{
customTargetSkillDriver = ai.skillDrivers.First(driver => driver.customName.Equals("CustomTargetLeash"));
bodyInteractor = master.GetBody().GetComponent <Interactor>();
this.stageCache = new StageCache();
}
}
private void SpawnPlayerCharacter()
{
// Spawn Player Character
if (m_PlayerSpawnTransform != null)
{
// Spawn character as a pooled object (in a pool of 1 object)
m_playerCharacterMaster = PlayerCharacterPoolManager.Instance.SpawnCharacter(m_PlayerSpawnTransform.position);
// Assign HUD's player health gauge to player health system (on Restart, it only refreshes the gauge)
var healthSystem = m_playerCharacterMaster.GetComponentOrFail <HealthSystem>();
HUD.Instance.AssignGaugeHealthPlayerTo(healthSystem);
}
}
public void LoadEquipment(CharacterMaster player, byte equipmentSlot)
{
var inventory = player.inventory;
var timeStampConstructor = typeof(FixedTimeStamp).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(float) }, null);
var chargeTime = (FixedTimeStamp)timeStampConstructor.Invoke(new object[] { chargeFinishTime });
var state = new EquipmentState(
(EquipmentIndex)index,
chargeTime,
charges
);
inventory.SetEquipment(state, equipmentSlot);
}
public override void Effect(GlobalEventManager globalEventManager, DamageInfo damageInfo, GameObject victim, int itemCount)
{
CharacterBody body = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody Attacker = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody characterBody = victim ? victim.GetComponent <CharacterBody>() : null;
CharacterMaster master = Attacker.master;
Inventory inventory = master.inventory;
TeamComponent Team = Attacker.GetComponent <TeamComponent>();
TeamIndex attackerTeamIndex = Team ? Team.teamIndex : TeamIndex.Neutral;
Vector3 aimOrigin = Attacker.aimOrigin;
ProcMissile(itemCount, Attacker, master, attackerTeamIndex, damageInfo.procChainMask, victim, damageInfo);
}
public override bool Effect(EquipmentSlot equipmentSlot)
{
var transform = equipmentSlot.transform;
var placementRules = new DirectorPlacementRule
{
placementMode = DirectorPlacementRule.PlacementMode.Approximate,
minDistance = 10f,
maxDistance = 100f,
spawnOnTarget = transform
};
var hateRequest = new DirectorSpawnRequest(hostileCard, placementRules, RoR2Application.rng)
{
ignoreTeamMemberLimit = false,
teamIndexOverride = TeamIndex.Monster
};
var spawn = DirectorCore.instance.TrySpawnObject(hateRequest);
spawn.transform.TransformDirection(0, 100, 0);
if (spawn)
{
CharacterMaster cm = spawn.GetComponent <CharacterMaster>();
if (cm)
{
cm.inventory.GiveItem(ItemIndex.BoostDamage, GetItemCountFromMultiplier(HostileDMG));
cm.inventory.GiveItem(ItemIndex.BoostHp, GetItemCountFromMultiplier((HostileHP)));
}
}
var friendRequest = new DirectorSpawnRequest(friendCard, placementRules, RoR2Application.rng)
{
ignoreTeamMemberLimit = false,
teamIndexOverride = TeamIndex.Player,
summonerBodyObject = equipmentSlot.GetComponent <CharacterBody>().gameObject
};
var spawn2 = DirectorCore.instance.TrySpawnObject(friendRequest);
spawn2.transform.TransformDirection(0, 100, 0);
if (spawn2)
{
CharacterMaster cm = spawn2.GetComponent <CharacterMaster>();
if (cm)
{
cm.inventory.GiveItem(ItemIndex.BoostDamage, GetItemCountFromMultiplier(AllyDMG));
cm.inventory.GiveItem(ItemIndex.BoostHp, GetItemCountFromMultiplier((AllyHP)));
}
}
if (spawn || spawn2)
{
return(true);
}
return(false);
}
public static void SendRichRandomizedPickupMessage(CharacterMaster origPlayer, PickupDef origPickup,
Dictionary <CharacterMaster, PickupDef> pickupIndices)
{
if (!GeneralHooks.IsMultiplayer() || !ShareSuite.RichMessagesEnabled.Value)
{
SendPickupMessage(origPlayer, origPickup.pickupIndex);
return;
}
// If nobody got a randomized item
if (pickupIndices.Count == 1)
{
SendRichPickupMessage(origPlayer, origPickup);
return;
}
var remainingPlayers = pickupIndices.Count;
var pickupMessage = "";
foreach (var index in pickupIndices)
{
var pickupColor = index.Value.baseColor;
var pickupName = Language.GetString(index.Value.nameToken);
var playerColor = GetPlayerColor(index.Key.playerCharacterMasterController);
if (remainingPlayers != pickupIndices.Count)
{
if (remainingPlayers > 1)
{
pickupMessage += $"<color=#{GrayColor}>,</color> ";
}
else if (remainingPlayers == 1)
{
pickupMessage += $"<color=#{GrayColor}>, and</color> ";
}
}
remainingPlayers--;
pickupMessage +=
$"<color=#{playerColor}>{index.Key.playerCharacterMasterController.GetDisplayName()}</color> " +
$"<color=#{GrayColor}>got</color> " +
$"<color=#{ColorUtility.ToHtmlStringRGB(pickupColor)}>" +
$"{pickupName ?? "???"}</color>";
}
Chat.SendBroadcastChat(new Chat.SimpleChatMessage {
baseToken = pickupMessage
});
}
public static void DropLastItem(CharacterMaster charMaster)
{
if (NetworkServer.active)
{
var inv = charMaster.inventory;
var pcmc = charMaster.playerCharacterMasterController;
string requesterName = pcmc.GetDisplayName();
if (LastPickedUpItem.ContainsKey(inv) && LastPickedUpItem[inv] != PickupIndex.none && inv.itemAcquisitionOrder.Any())
{
PickupDef pickupDef = PickupCatalog.GetPickupDef(LastPickedUpItem[inv]);
LastPickedUpItem[inv] = PickupIndex.none;
if (pickupDef.equipmentIndex != EquipmentIndex.None)
{
if (inv.GetEquipmentIndex() != pickupDef.equipmentIndex)
{
Logger.LogWarning($"'{requesterName}' tried to drop an equipment item they don't have! ({pickupDef.equipmentIndex})");
return;
}
inv.SetEquipmentIndex(EquipmentIndex.None);
}
else
{
if (inv.GetItemCount(pickupDef.itemIndex) <= 0)
{
Logger.LogWarning($"'{requesterName}' tried to drop an item they don't have! ({pickupDef.itemIndex})");
return;
}
inv.RemoveItem(pickupDef.itemIndex, 1);
}
var transform = charMaster.GetBody()?.coreTransform;
if (transform != null)
{
PickupDropletController.CreatePickupDroplet(pickupDef.pickupIndex,
transform.position,
transform.up * 15f + transform.forward * 10f);
}
Logger.LogInfo($"'{requesterName}' dropped '{Language.GetString(pickupDef.nameToken)}'");
}
else
{
Logger.LogDebug($"'{requesterName}' tried to drop an item but is not allowed.");
}
}
else
{
Logger.LogWarning("DropLastItem called on client!");
}
}
private static bool AttemptDrop(CharacterMaster atkMaster, EquipmentDef equipDef, CharacterBody vicBody)
{
EquipmentIndex index = equipDef.equipmentIndex;
if (Catalog.GetEquipmentEliteDef(equipDef) == null)
{
return(false);
}
if (Catalog.ItemizeEliteEquipment(index) == ItemIndex.None)
{
return(false);
}
if (disableDrops)
{
return(false);
}
float chance = GetDropChance(index);
if (Configuration.AspectDropVerboseLogging.Value)
{
Logger.Info("Elite Killed - Rolling aspect drop chance!");
Logger.Info("--Victim : " + vicBody.name + "[" + vicBody.netId + "] Equipment : " + equipDef.name);
Logger.Info("--Aspect drop chance : " + chance);
}
if (chance <= 0f)
{
return(false);
}
if (CheckDropRoll(chance, atkMaster))
{
runDropCount++;
UpdateZetDropTracker();
Logger.Info("RunDropCount : " + runDropCount);
LogDropChance();
if (Configuration.AspectShowDropText.Value)
{
Chat.SendBroadcastChat(new Chat.SimpleChatMessage
{
baseToken = "<color=#DDDDA0><size=120%>" + Configuration.AspectDropText.Value + "</color></size>"
});
}
return(true);
}
return(false);
}
// Token: 0x06002311 RID: 8977 RVA: 0x000A5264 File Offset: 0x000A3464
public void SetCurrentMaster(CharacterMaster newMaster)
{
if (newMaster == this.currentMaster)
{
return;
}
for (int i = this.objectiveTrackers.Count - 1; i >= 0; i--)
{
UnityEngine.Object.Destroy(this.objectiveTrackers[i].stripObject);
}
this.objectiveTrackers.Clear();
this.currentMaster = newMaster;
this.RefreshObjectiveTrackers();
}
/// <summary>
/// Fetches all the minions and fellow minions, then returns a list of the minions' component.
/// </summary>
/// <typeparam name="T">Component to match</typeparam>
/// <param name="ownerOrMinion">Master of the minions</param>
/// <returns>List of components of the minions</returns>
public static List <T> GetAllMinionComponents <T>(this CharacterMaster ownerOrMinion) where T : Component
{
List <T> list = new List <T>();
LoopMinions(ownerOrMinion, (minion) =>
{
T component = minion.gameObject.GetComponent <T>();
if (component)
{
list.Add(component);
}
});
return(list);
}
private bool CanDeploy(EquipmentSlot equipmentSlot, DeployableSlot deployableSlot)
{
CharacterMaster master = equipmentSlot.characterBody.master;
if (!master)
{
return(false);
}
if (master.GetDeployableCount(deployableSlot) >= master.GetDeployableSameSlotLimit(deployableSlot))
{
return(false);
}
return(true);
}
private void PickupPickerController_FixedUpdateServer(On.RoR2.PickupPickerController.orig_FixedUpdateServer orig, PickupPickerController self)
{
CharacterMaster currentParticipantMaster = self.networkUIPromptController.currentParticipantMaster;
if (currentParticipantMaster)
{
CharacterBody body = currentParticipantMaster.GetBody();
var interactor = (body)? body.GetComponent <Interactor>(): null;
if (!body || (body.inputBank.aimOrigin - self.transform.position).sqrMagnitude > ((interactor)? Math.Pow((interactor.maxInteractionDistance + self.cutoffDistance), 2f): (self.cutoffDistance * self.cutoffDistance)))
{
self.networkUIPromptController.SetParticipantMaster(null);
}
}
}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
private void Flamethrower_FireGauntlet(On.EntityStates.Mage.Weapon.Flamethrower.orig_FireGauntlet orig, MageWeapon.Flamethrower self, string muzzleString)
{
orig(self, muzzleString);
CharacterBody body = self.characterBody;
if (body)
{
CharacterMaster master = body.master;
if (master && body.name.Contains("FlameDrone") && master.name.Contains("FlameDrone"))
{
TriggerArtillery(self.characterBody, self.tickDamageCoefficient * self.damageStat, self.isCrit);
}
}
}
private void CreateDoppelganger()
{
// set up the doppelganger for artifact of vengeance here
doppelganger = PrefabAPI.InstantiateClone(Resources.Load <GameObject>("Prefabs/CharacterMasters/CommandoMonsterMaster"), "ZukoMonsterMaster", true, "D:\\Ror2Mod\\Zuko-RoR2-Mod\\ZukoProject\\Zuko.cs", "CreateDoppelganger", 181);
MasterCatalog.getAdditionalEntries += delegate(List <GameObject> list)
{
list.Add(doppelganger);
};
CharacterMaster component = doppelganger.GetComponent <CharacterMaster>();
component.bodyPrefab = characterPrefab;
}
public static void TrySpawnEnemy(CharacterBody body)
{
string variantName = body.baseNameToken;
bool variantIsSpecial = true; //Wether or not this variant spawns enemies on death.
switch (variantName)
{
case "Wisp Amalgamate":
enemyCard = "LesserWisp";
amount = 5;
break;
case "M.O.A.J.":
enemyCard = "Jellyfish";
amount = 5;
break;
case "Amalgamated Ancient Wisp":
enemyCard = "GreaterWisp";
amount = 5;
break;
default:
variantIsSpecial = false;
break;
}
if (variantIsSpecial)
{
Vector3 position = body.corePosition + (amount * UnityEngine.Random.insideUnitSphere);
DirectorSpawnRequest directorSpawnRequest = new DirectorSpawnRequest((SpawnCard)Resources.Load(string.Format("SpawnCards/CharacterSpawnCards/csc" + enemyCard)), new DirectorPlacementRule
{
placementMode = DirectorPlacementRule.PlacementMode.Direct,
minDistance = 0f,
maxDistance = 4f,
position = position
}, RoR2Application.rng);
directorSpawnRequest.summonerBodyObject = body.gameObject;
for (int i = 0; i < amount; i++)
{
GameObject enemy = DirectorCore.instance.TrySpawnObject(directorSpawnRequest);
if (enemy)
{
CharacterMaster master = enemy.GetComponent <CharacterMaster>();
enemy.GetComponent <Inventory>().SetEquipmentIndex(body.inventory.currentEquipmentIndex);
}
}
}
}
static public void ModdedHitAll(On.RoR2.GlobalEventManager.orig_OnHitAll orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
if ((double)damageInfo.procCoefficient == 0.0)
{
return;
}
int Host = NetworkServer.active ? 1 : 0;
if (!(bool)((UnityEngine.Object)damageInfo.attacker))
{
return;
}
CharacterBody component = damageInfo.attacker.GetComponent <CharacterBody>();
if (!(bool)((UnityEngine.Object)component))
{
return;
}
CharacterMaster master = component.master;
if (!(bool)((UnityEngine.Object)master))
{
return;
}
Inventory inventory = master.inventory;
if (!(bool)((UnityEngine.Object)master.inventory))
{
return;
}
damageInfo.procChainMask.LinkToManager();
ModItemManager.OnHitAllEffects(self, damageInfo, victim);
//Buff
if ((component.HasBuff(BuffIndex.AffixBlue) ? 1 : 0) <= 0)
{
return;
}
float damage = damageInfo.damage * 0.5f;
float force = 0.0f;
Vector3 position = damageInfo.position;
#pragma warning disable CS0618 //Obsolete warning
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/LightningStake"), position, Quaternion.identity, damageInfo.attacker, damage, force, damageInfo.crit, DamageColorIndex.Item, (GameObject)null, -1f);
#pragma warning restore CS0618
damageInfo.procChainMask.UnlinkToManager();
}
public static BotStatTracker GetOrAddComponent(CharacterMaster bot, CharacterMaster owner, CharacterBody botBody, CharacterBody ownerBody)
{
BotStatTracker tracker = bot.gameObject.GetComponent <BotStatTracker>();
if (!tracker)
{
tracker = bot.gameObject.AddComponent <BotStatTracker>();
tracker.BotMaster = bot;
tracker.BotOwnerMaster = owner;
}
tracker.BotBody = botBody;
tracker.BotOwnerBody = ownerBody;
return(tracker);
}
// Token: 0x06001C7F RID: 7295 RVA: 0x00079B77 File Offset: 0x00077D77
public static PlayerStatsComponent FindBodyStatsComponent(CharacterBody characterBody)
{
if (characterBody == null)
{
return(null);
}
CharacterMaster master = characterBody.master;
if (master == null)
{
return(null);
}
return(master.GetComponent <PlayerStatsComponent>());
}
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
private void On_GEMOnHitEnemy(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
orig(self, damageInfo, victim);
if (!NetworkServer.active || !victim || !damageInfo.attacker || damageInfo.procCoefficient <= 0f)
{
return;
}
var vicb = victim.GetComponent <CharacterBody>();
CharacterBody body = damageInfo.attacker.GetComponent <CharacterBody>();
if (!body || !vicb || !vicb.healthComponent || !vicb.mainHurtBox || vicb.HasBuff(poisonBuff))
{
return;
}
CharacterMaster chrm = body.master;
if (!chrm)
{
return;
}
int icnt = GetCount(body);
if (icnt == 0)
{
return;
}
icnt--;
float m2Proc = procChance;
if (icnt > 0)
{
m2Proc += stackChance * icnt;
}
if (m2Proc > capChance)
{
m2Proc = capChance;
}
if (!Util.CheckRoll(m2Proc * damageInfo.procCoefficient, chrm))
{
return;
}
DotController.InflictDot(victim, damageInfo.attacker, poisonDot, duration);
}
private void LoopAllMinionOwnerships(CharacterMaster triggerer, Action <CharacterBody> actionToRun)
{
triggerer.LoopMinions((minionMaster) =>
{
if (minionMaster && DronesList.Exists((item) => minionMaster.name.Contains(item)))
{
CharacterBody minionBody = minionMaster.GetBody();
if (minionBody)
{
actionToRun(minionBody);
}
}
});
}
private static void PoisonOnHit_OnHit(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager gem,
DamageInfo damageInfo, [NotNull] GameObject victim)
{
try
{
if (damageInfo.procCoefficient == 0f || damageInfo.rejected)
{
return;
}
if (!NetworkServer.active)
{
return;
}
CharacterBody component = damageInfo.attacker.GetComponent <CharacterBody>();
CharacterBody characterBody = victim ? victim.GetComponent <CharacterBody>() : null;
if (component)
{
CharacterMaster master = component.master;
if (master)
{
Inventory inventory = master.inventory;
TeamComponent component2 = component.GetComponent <TeamComponent>();
TeamIndex teamIndex = component2 ? component2.teamIndex : TeamIndex.Neutral;
Vector3 aimOrigin = component.aimOrigin;
int itemCount2 = inventory.GetItemCount(GNCItemSuite.PoisonOnHitItemIndex);
int itemCount3 = inventory.GetItemCount(GNCItemSuite.BlightOnHitItemIndex);
if ((itemCount2 > 0) && (Util.CheckRoll(5f * (float)itemCount2 * damageInfo.procCoefficient, master)))
{
ProcChainMask procChainMask2 = damageInfo.procChainMask;
procChainMask2.AddProc(ProcType.BleedOnHit);
DotController.InflictDot(victim, damageInfo.attacker, DotController.DotIndex.Poison, 10f * damageInfo.procCoefficient, 1f);
}
if ((itemCount3 > 0) && (Util.CheckRoll(10f * (float)itemCount3 * damageInfo.procCoefficient, master)))
{
ProcChainMask procChainMask2 = damageInfo.procChainMask;
procChainMask2.AddProc(ProcType.BleedOnHit);
DotController.InflictDot(victim, damageInfo.attacker, DotController.DotIndex.Blight, 10f * damageInfo.procCoefficient, 1f);
}
}
}
}
catch
{
}
orig(gem, damageInfo, victim);
}
