// Token: 0x06002F99 RID: 12185 RVA: 0x000CBD3C File Offset: 0x000C9F3C
private void FireOrbArrow()
{
if (hasFiredArrow || !NetworkServer.active)
{
return;
}
hasFiredArrow = true;
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.lightningType = (LightningOrb.LightningType)(-1);
lightningOrb.damageValue = base.characterBody.damage * 0.5f;
lightningOrb.isCrit = Util.CheckRoll(base.characterBody.crit, base.characterBody.master);
lightningOrb.teamIndex = TeamComponent.GetObjectTeam(base.gameObject);
lightningOrb.attacker = base.gameObject;
lightningOrb.procCoefficient = 0.08f;
lightningOrb.bouncesRemaining = 2;
lightningOrb.speed = 55;
lightningOrb.bouncedObjects = new List <HealthComponent>();
lightningOrb.range = 100;
lightningOrb.damageCoefficientPerBounce = 1f;
lightningOrb.SetFieldValue("canBounceOnSameTarget", true);
HurtBox hurtBox = initialOrbTarget;
if (hurtBox)
{
lightningOrb.origin = transform.position;
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
protected override void Serialize(NetworkWriter writer, LightningOrb orb)
{
base.Serialize(writer, orb);
writer.Write(orb.speed);
writer.Write(orb.damageValue);
writer.Write(orb.attacker);
writer.Write(orb.inflictor);
writer.Write(orb.bouncesRemaining);
writer.Write(orb.bouncedObjects.Count);
for (Int32 i = 0; i < orb.bouncedObjects.Count; ++i)
{
writer.Write(orb.bouncedObjects[i].body);
}
writer.Write(orb.teamIndex);
writer.Write(orb.isCrit);
writer.Write(orb.procChainMask);
writer.Write(orb.procCoefficient);
writer.Write(orb.damageColorIndex);
writer.Write(orb.range);
writer.Write(orb.damageCoefficientPerBounce);
writer.Write(orb.targetsToFindPerBounce);
writer.Write(orb.damageType);
writer.WriteBits(orb.lightningType);
}
protected override void Deserialize(NetworkReader reader, ref LightningOrb orb)
{
base.Deserialize(reader, ref orb);
orb.speed = reader.ReadSingle();
orb.damageValue = reader.ReadSingle();
orb.attacker = reader.ReadGameObject();
orb.inflictor = reader.ReadGameObject();
orb.bouncesRemaining = reader.ReadInt32();
//Needs null checks
var c = reader.ReadInt32();
orb.bouncedObjects = new(c);
for (Int32 i = 0; i < c; i++)
{
orb.bouncedObjects.Add(reader.ReadNetworkIdentity().GetComponent <CharacterBody>().healthComponent);
}
orb.teamIndex = reader.ReadTeamIndex();
orb.isCrit = reader.ReadBoolean();
orb.procChainMask = reader.ReadProcChainMask();
orb.procCoefficient = reader.ReadSingle();
orb.damageColorIndex = reader.ReadDamageColorIndex();
orb.range = reader.ReadSingle();
orb.damageCoefficientPerBounce = reader.ReadSingle();
orb.targetsToFindPerBounce = reader.ReadInt32();
orb.damageType = reader.ReadDamageType();
orb.lightningType = reader.ReadBits <LightningOrb.LightningType>();
}
// Token: 0x06001EA6 RID: 7846 RVA: 0x000909BC File Offset: 0x0008EBBC
private void UpdateServer()
{
this.listClearTimer -= Time.fixedDeltaTime;
if (this.listClearTimer <= 0f)
{
this.ClearList();
this.listClearTimer = this.listClearInterval;
}
this.attackTimer -= Time.fixedDeltaTime;
if (this.attackTimer <= 0f)
{
this.attackTimer = this.attackInterval;
Vector3 position = base.transform.position;
HurtBox hurtBox = this.FindNextTarget(position);
if (hurtBox)
{
this.previousTargets.Add(hurtBox.healthComponent);
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.attacker = this.projectileController.owner;
lightningOrb.teamIndex = this.myTeamIndex;
lightningOrb.damageValue = this.projectileDamage.damage * this.damageCoefficient;
lightningOrb.isCrit = this.projectileDamage.crit;
lightningOrb.origin = position;
lightningOrb.bouncesRemaining = 0;
lightningOrb.lightningType = this.lightningType;
lightningOrb.procCoefficient = this.procCoefficient;
lightningOrb.target = hurtBox;
lightningOrb.damageColorIndex = this.projectileDamage.damageColorIndex;
OrbManager.instance.AddOrb(lightningOrb);
}
}
}
private static void GlobalEventManager_OnHitEnemy(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
orig(self, damageInfo, victim);
if (damageInfo.attacker && damageInfo.attacker.GetComponent <CharacterBody>())
{
var attackerBody = damageInfo.attacker.GetComponent <CharacterBody>();
if (attackerBody.HasBuff(PylonPoweredBuff.BuffDef) && !damageInfo.procChainMask.HasProc(ProcType.LoaderLightning))
{
float damageValue = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, pylonPowerDamageCoefficient);
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.origin = damageInfo.position;
lightningOrb.damageValue = damageValue;
lightningOrb.isCrit = damageInfo.crit;
lightningOrb.bouncesRemaining = pylonPowerMaxBounces;
lightningOrb.teamIndex = attackerBody.teamComponent ? attackerBody.teamComponent.teamIndex : TeamIndex.None;
lightningOrb.attacker = damageInfo.attacker;
lightningOrb.bouncedObjects = new List <HealthComponent>
{
victim.GetComponent <HealthComponent>()
};
lightningOrb.procChainMask = damageInfo.procChainMask;
lightningOrb.procChainMask.AddProc(ProcType.LoaderLightning);
lightningOrb.procCoefficient = 0f;
lightningOrb.lightningType = LightningOrb.LightningType.Loader;
lightningOrb.damageColorIndex = DamageColorIndex.Item;
lightningOrb.range = pylonPowerRange;
HurtBox hurtBox = lightningOrb.PickNextTarget(damageInfo.position);
if (hurtBox)
{
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
}
}
private void FireLightningSpell()
{
ChainLightningOrb newOrb = new ChainLightningOrb()
{
lightningType = LightningOrb.LightningType.Ukulele,
damageValue = this.damageStat * StaticValues.lightningDamageCoefficient * this.fireDamageBonus,
damageCoefficientPerBounce = StaticValues.lightningBounceDamageMulti,
procCoefficient = StaticValues.lightningProcCoefficient,
bouncesRemaining = StaticValues.lightningBounceCount,
range = StaticValues.lightningBounceRange,
teamIndex = TeamComponent.GetObjectTeam(base.gameObject),
isCrit = base.RollCrit(),
attacker = base.gameObject,
bouncedObjects = new List <HealthComponent>(),
speed = 0f,
orbEffectName = "ChainLightningOrbEffect",
duration = 0.1f,
skillSlot = this.activatorSkillSlot,
useBonus = true
};
HurtBox hurtBox = this.initialOrbTarget;
if (hurtBox)
{
Transform transform = this.childLocator.FindChild("hand.l");
newOrb.origin = transform.position;
newOrb.target = hurtBox;
OrbManager.instance.AddOrb(newOrb);
this.successfulFire = true;
}
this.hasFired = true;
this.firedOrb = newOrb;
}
// Token: 0x06002FA9 RID: 12201 RVA: 0x000CC4A8 File Offset: 0x000CA6A8
private void FireOrbGlaive()
{
if (!NetworkServer.active || this.hasTriedToThrowGlaive)
{
return;
}
this.hasTriedToThrowGlaive = true;
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.lightningType = LightningOrb.LightningType.HuntressGlaive;
lightningOrb.damageValue = base.characterBody.damage * ThrowGlaive.damageCoefficient;
lightningOrb.isCrit = Util.CheckRoll(base.characterBody.crit, base.characterBody.master);
lightningOrb.teamIndex = TeamComponent.GetObjectTeam(base.gameObject);
lightningOrb.attacker = base.gameObject;
lightningOrb.procCoefficient = ThrowGlaive.glaiveProcCoefficient;
lightningOrb.bouncesRemaining = ThrowGlaive.maxBounceCount;
lightningOrb.speed = ThrowGlaive.glaiveTravelSpeed;
lightningOrb.bouncedObjects = new List <HealthComponent>();
lightningOrb.range = ThrowGlaive.glaiveBounceRange;
lightningOrb.damageCoefficientPerBounce = ThrowGlaive.damageCoefficientPerBounce;
HurtBox hurtBox = this.initialOrbTarget;
if (hurtBox)
{
this.hasSuccessfullyThrownGlaive = true;
Transform transform = this.childLocator.FindChild("HandR");
EffectManager.SimpleMuzzleFlash(ThrowGlaive.muzzleFlashPrefab, base.gameObject, "HandR", true);
lightningOrb.origin = transform.position;
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
private void OrbManager_AddOrb(On.RoR2.Orbs.OrbManager.orig_AddOrb orig, RoR2.Orbs.OrbManager self, RoR2.Orbs.Orb orb)
{
MoreItems.print(bouncedOrbs.Count);
if (orb is RoR2.Orbs.LightningOrb lightningOrb && lightningOrb.attacker)
{
if (lightningOrb.attacker.GetComponent <CharacterBody>() is CharacterBody characterBody && characterBody.inventory)
{
if (characterBody.inventory.GetItemCount(this.ItemIndex) is int count)
{
if (!bouncedOrbs.Contains(lightningOrb))
{
for (int i = 0; i < count; i++)
{
LightningOrb lightningOrbCopy = new LightningOrb();
lightningOrbCopy.search = new BullseyeSearch();
lightningOrbCopy.origin = lightningOrb.target.transform.position;
lightningOrbCopy.target = lightningOrb.target;
lightningOrbCopy.attacker = lightningOrb.attacker;
lightningOrbCopy.inflictor = lightningOrb.inflictor;
lightningOrbCopy.teamIndex = lightningOrb.teamIndex;
lightningOrbCopy.damageValue = lightningOrb.damageValue;
lightningOrbCopy.bouncesRemaining = lightningOrb.bouncesRemaining;
lightningOrbCopy.isCrit = lightningOrb.isCrit;
lightningOrbCopy.bouncedObjects = new List <HealthComponent>(lightningOrb.bouncedObjects);
lightningOrbCopy.lightningType = lightningOrb.lightningType;
lightningOrbCopy.procChainMask = lightningOrb.procChainMask;
lightningOrbCopy.procCoefficient = lightningOrb.procCoefficient;
lightningOrbCopy.damageColorIndex = lightningOrb.damageColorIndex;
lightningOrbCopy.damageCoefficientPerBounce = lightningOrb.damageCoefficientPerBounce;
lightningOrbCopy.speed = lightningOrb.speed;
lightningOrbCopy.range = lightningOrb.range;
lightningOrbCopy.damageType = lightningOrb.damageType;
lightningOrbCopy.failedToKill = lightningOrb.failedToKill;
orig(self, lightningOrbCopy);
}
}
else
{
bouncedOrbs.Remove(lightningOrb);
}
}
}
}
static private void OrbManager_AddOrb(Action <RoR2.Orbs.OrbManager, RoR2.Orbs.Orb> orig, RoR2.Orbs.OrbManager self, RoR2.Orbs.Orb orb)
{
if (orb is RoR2.Orbs.LightningOrb lightningOrb && lightningOrb.attacker)
{
if (lightningOrb.attacker.GetComponent <CharacterBody>() is CharacterBody characterBody)
{
if (!bouncedOrbs.Contains(lightningOrb))
{
for (int i = 0; i < rollAttackCount(characterBody); i++)
{
LightningOrb lightningOrbCopy = new LightningOrb
{
search = new BullseyeSearch(),
origin = lightningOrb.origin,
target = lightningOrb.target,
attacker = lightningOrb.attacker,
inflictor = lightningOrb.inflictor,
teamIndex = lightningOrb.teamIndex,
damageValue = lightningOrb.damageValue,
bouncesRemaining = lightningOrb.bouncesRemaining,
isCrit = lightningOrb.isCrit,
bouncedObjects = lightningOrb.bouncedObjects != null ? new List <HealthComponent>(lightningOrb.bouncedObjects) : new List <HealthComponent>(),
lightningType = lightningOrb.lightningType,
procChainMask = lightningOrb.procChainMask,
procCoefficient = lightningOrb.procCoefficient,
damageColorIndex = lightningOrb.damageColorIndex,
damageCoefficientPerBounce = lightningOrb.damageCoefficientPerBounce,
speed = lightningOrb.speed,
range = lightningOrb.range,
damageType = lightningOrb.damageType,
failedToKill = lightningOrb.failedToKill
};
orig(self, lightningOrbCopy);
}
}
else
{
bouncedOrbs.Remove(lightningOrb);
}
}
}
private void GlobalEventManager_OnHitEnemy(On.RoR2.GlobalEventManager.orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
{
orig(self, damageInfo, victim);
if (damageInfo.attacker && damageInfo.procCoefficient >= 1f)
{
CharacterBody attackerBody = damageInfo.attacker.GetComponent <CharacterBody>();
if (attackerBody)
{
if (attackerBody.HasBuff(Modules.Buffs.overchargeBuff))
{
float damageCoefficient = 0.75f;
float damageValue = Util.OnHitProcDamage(damageInfo.damage, attackerBody.damage, damageCoefficient);
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.origin = damageInfo.position;
lightningOrb.damageValue = damageValue;
lightningOrb.isCrit = damageInfo.crit;
lightningOrb.bouncesRemaining = 3;
lightningOrb.teamIndex = attackerBody.teamComponent.teamIndex;
lightningOrb.attacker = damageInfo.attacker;
lightningOrb.bouncedObjects = new List <HealthComponent>
{
victim.GetComponent <HealthComponent>()
};
lightningOrb.procChainMask = damageInfo.procChainMask;
lightningOrb.procChainMask.AddProc(ProcType.ChainLightning);
lightningOrb.procCoefficient = 0f;
lightningOrb.lightningType = LightningOrb.LightningType.Loader;
lightningOrb.damageColorIndex = DamageColorIndex.Default;
lightningOrb.range += 6f;
HurtBox hurtBox = lightningOrb.PickNextTarget(damageInfo.position);
if (hurtBox)
{
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
}
}
}
// Token: 0x060031A5 RID: 12709 RVA: 0x000D5D40 File Offset: 0x000D3F40
public override void OnEnter()
{
base.OnEnter();
this.duration = Disease.baseDuration / this.attackSpeedStat;
Ray aimRay = base.GetAimRay();
Transform transform = base.FindModelChild(Disease.muzzleString);
BullseyeSearch bullseyeSearch = new BullseyeSearch();
bullseyeSearch.searchOrigin = aimRay.origin;
bullseyeSearch.searchDirection = aimRay.direction;
bullseyeSearch.maxDistanceFilter = Disease.orbRange;
bullseyeSearch.teamMaskFilter = TeamMask.allButNeutral;
bullseyeSearch.teamMaskFilter.RemoveTeam(TeamComponent.GetObjectTeam(base.gameObject));
bullseyeSearch.sortMode = BullseyeSearch.SortMode.DistanceAndAngle;
bullseyeSearch.RefreshCandidates();
EffectManager.SimpleMuzzleFlash(Disease.muzzleflashEffectPrefab, base.gameObject, Disease.muzzleString, true);
List <HurtBox> list = bullseyeSearch.GetResults().ToList <HurtBox>();
if (list.Count > 0)
{
Debug.LogFormat("Shooting at {0}", new object[]
{
list[0]
});
HurtBox target = list.FirstOrDefault <HurtBox>();
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.attacker = base.gameObject;
lightningOrb.bouncedObjects = new List <HealthComponent>();
lightningOrb.lightningType = LightningOrb.LightningType.CrocoDisease;
lightningOrb.damageType = DamageType.PoisonOnHit;
lightningOrb.damageValue = this.damageStat * Disease.damageCoefficient;
lightningOrb.isCrit = base.RollCrit();
lightningOrb.procCoefficient = Disease.procCoefficient;
lightningOrb.bouncesRemaining = Disease.maxBounces;
lightningOrb.origin = transform.position;
lightningOrb.target = target;
lightningOrb.teamIndex = base.GetTeam();
lightningOrb.range = Disease.bounceRange;
OrbManager.instance.AddOrb(lightningOrb);
}
}
// Token: 0x060012B1 RID: 4785 RVA: 0x0005BB98 File Offset: 0x00059D98
public void BlockedDamage(DamageInfo damageInfo, float actualDamageBlocked)
{
this.totalDamageBlocked += actualDamageBlocked;
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.teamIndex = this.teamComponent.teamIndex;
lightningOrb.origin = damageInfo.position;
lightningOrb.damageValue = actualDamageBlocked * this.blockLaserDamageCoefficient;
lightningOrb.bouncesRemaining = 0;
lightningOrb.attacker = damageInfo.attacker;
lightningOrb.procCoefficient = this.blockLaserProcCoefficient;
lightningOrb.lightningType = LightningOrb.LightningType.PaladinBarrier;
HurtBox hurtBox = lightningOrb.PickNextTarget(lightningOrb.origin);
if (hurtBox)
{
lightningOrb.target = hurtBox;
lightningOrb.isCrit = Util.CheckRoll(this.characterBody.crit, this.characterBody.master);
OrbManager.instance.AddOrb(lightningOrb);
}
}
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;
float damageCoefficient = 0.8f;
float Damage = Util.OnHitProcDamage(damageInfo.damage, Attacker.damage, damageCoefficient);
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.origin = damageInfo.position;
lightningOrb.damageValue = Damage;
lightningOrb.isCrit = damageInfo.crit;
lightningOrb.bouncesRemaining = 2 * itemCount;
lightningOrb.teamIndex = attackerTeamIndex;
lightningOrb.attacker = damageInfo.attacker;
lightningOrb.bouncedObjects = new List <HealthComponent>()
{
victim.GetComponent <HealthComponent>()
};
lightningOrb.procChainMask = damageInfo.procChainMask;
lightningOrb.procChainMask.AddProc(ProcType.ChainLightning);
lightningOrb.procCoefficient = 0.2f;
lightningOrb.lightningType = LightningOrb.LightningType.Ukulele;
lightningOrb.damageColorIndex = DamageColorIndex.Item;
lightningOrb.range += 2 * itemCount;
HurtBox hurtBox = lightningOrb.PickNextTarget(damageInfo.position);
if (hurtBox)
{
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
// Token: 0x06002DEA RID: 11754 RVA: 0x000C36CC File Offset: 0x000C18CC
private void FireSecondaryRaysServer()
{
Ray aimRay = base.GetAimRay();
TeamIndex team = base.GetTeam();
BullseyeSearch bullseyeSearch = new BullseyeSearch();
bullseyeSearch.teamMaskFilter = TeamMask.AllExcept(team);
bullseyeSearch.maxAngleFilter = BigPunch.maxShockFOV * 0.5f;
bullseyeSearch.maxDistanceFilter = BigPunch.maxShockDistance;
bullseyeSearch.searchOrigin = aimRay.origin;
bullseyeSearch.searchDirection = this.punchVector;
bullseyeSearch.sortMode = BullseyeSearch.SortMode.Distance;
bullseyeSearch.filterByLoS = false;
bullseyeSearch.RefreshCandidates();
List <HurtBox> list = bullseyeSearch.GetResults().Where(new Func <HurtBox, bool>(Util.IsValid)).ToList <HurtBox>();
Transform transform = base.FindModelChild(this.swingEffectMuzzleString);
if (transform)
{
for (int i = 0; i < Mathf.Min(list.Count, BigPunch.maxShockCount); i++)
{
HurtBox hurtBox = list[i];
if (hurtBox)
{
LightningOrb lightningOrb = new LightningOrb();
lightningOrb.bouncedObjects = new List <HealthComponent>();
lightningOrb.attacker = base.gameObject;
lightningOrb.teamIndex = team;
lightningOrb.damageValue = this.damageStat * BigPunch.shockDamageCoefficient;
lightningOrb.isCrit = base.RollCrit();
lightningOrb.origin = transform.position;
lightningOrb.bouncesRemaining = 0;
lightningOrb.lightningType = LightningOrb.LightningType.Loader;
lightningOrb.procCoefficient = BigPunch.shockProcCoefficient;
lightningOrb.target = hurtBox;
OrbManager.instance.AddOrb(lightningOrb);
}
}
}
}
public static void AddHook()
{
On.RoR2.GlobalEventManager.OnHitEnemy += (orig, self, damageInfo, victim) =>
{
CharacterBody victimBody = null;
bool hadSpotter = false;
bool hadSpotterScepter = false;
if (victim)
{
victimBody = victim.GetComponent <CharacterBody>();
if (victimBody)
{
if (victimBody.HasBuff(SniperContent.spotterBuff) || victimBody.HasBuff(SniperContent.spotterScepterBuff))
{
hadSpotter = true;
if (victimBody.HasBuff(SniperContent.spotterScepterBuff))
{
hadSpotterScepter = true;
}
}
}
}
orig(self, damageInfo, victim);
if (!damageInfo.rejected && hadSpotter)
{
if (damageInfo.attacker)
{
CharacterBody attackerBody = damageInfo.attacker.GetComponent <CharacterBody>();
if (attackerBody)
{
if (damageInfo.procCoefficient > 0f && !(damageInfo.damage / attackerBody.damage < 4f))
{
if (victimBody && victimBody.healthComponent && victimBody.healthComponent.alive)
{
if (victimBody.HasBuff(SniperContent.spotterBuff))
{
victimBody.RemoveBuff(SniperContent.spotterBuff);
}
if (victimBody.HasBuff(SniperContent.spotterScepterBuff))
{
victimBody.RemoveBuff(SniperContent.spotterScepterBuff);
}
for (int i = 1; i <= 10; i++)
{
victimBody.AddTimedBuff(SniperContent.spotterCooldownBuff, i);
}
}
LightningOrb spotterLightning = new LightningOrb
{
attacker = damageInfo.attacker,
inflictor = damageInfo.attacker,
damageValue = damageInfo.damage * (hadSpotterScepter ? 1f : 0.5f),
procCoefficient = 0.5f,
teamIndex = attackerBody.teamComponent.teamIndex,
isCrit = damageInfo.crit,
procChainMask = damageInfo.procChainMask,
lightningType = LightningOrb.LightningType.Tesla,
damageColorIndex = DamageColorIndex.Nearby,
bouncesRemaining = 5 * (hadSpotterScepter ? 2 : 1),
targetsToFindPerBounce = 5 * (hadSpotterScepter ? 2 : 1),
range = 20f * (hadSpotterScepter ? 2f : 1f),
origin = damageInfo.position,
damageType = (DamageType.SlowOnHit | DamageType.Stun1s),
speed = 120f
};
spotterLightning.bouncedObjects = new List <HealthComponent>();
SpotterLightningController stc = damageInfo.attacker.GetComponent <SpotterLightningController>();
if (stc)
{
stc.QueueLightning(spotterLightning, 0.1f);
}
}
}
}
}
};
}
public override void OnLoad()
{
base.OnLoad();
itemDef.name = "MysticsItems_Voltmeter";
SetItemTierWhenAvailable(ItemTier.Tier3);
itemDef.tags = new ItemTag[]
{
ItemTag.Damage,
ItemTag.Utility,
ItemTag.AIBlacklist,
ItemTag.BrotherBlacklist
};
itemDef.pickupModelPrefab = PrepareModel(Main.AssetBundle.LoadAsset <GameObject>("Assets/Items/Voltmeter/Model.prefab"));
itemDef.pickupIconSprite = Main.AssetBundle.LoadAsset <Sprite>("Assets/Items/Voltmeter/Icon.png");
Material matVoltmeterCoil = itemDef.pickupModelPrefab.transform.Find("÷илиндр.001").GetComponent <MeshRenderer>().sharedMaterial;
HopooShaderToMaterial.Standard.Apply(matVoltmeterCoil);
HopooShaderToMaterial.Standard.Emission(matVoltmeterCoil, 2f, matVoltmeterCoil.color);
Material matVoltmeter = itemDef.pickupModelPrefab.transform.Find("Cube").GetComponent <MeshRenderer>().sharedMaterial;
HopooShaderToMaterial.Standard.Apply(matVoltmeter);
HopooShaderToMaterial.Standard.Gloss(matVoltmeter, 0.09f);
HopooShaderToMaterial.Standard.Emission(matVoltmeter, 0.2f, new Color32(52, 37, 29, 255));
PointerAnimator pointerAnimator = itemDef.pickupModelPrefab.AddComponent <PointerAnimator>();
pointerAnimator.pointer = itemDef.pickupModelPrefab.transform.Find("PointerCenter").gameObject;
itemDisplayPrefab = PrepareItemDisplayModel(PrefabAPI.InstantiateClone(itemDef.pickupModelPrefab, itemDef.pickupModelPrefab.name + "Display", false));
onSetupIDRS += () =>
{
AddDisplayRule("CommandoBody", "Stomach", new Vector3(0.042F, 0.096F, -0.119F), new Vector3(4.394F, 73.472F, 2.074F), new Vector3(0.02F, 0.02F, 0.02F));
AddDisplayRule("HuntressBody", "Pelvis", new Vector3(0.077F, -0.096F, 0.09F), new Vector3(358.51F, 111.069F, 197.846F), new Vector3(0.018F, 0.018F, 0.018F));
AddDisplayRule("Bandit2Body", "Chest", new Vector3(0.011F, 0.206F, -0.199F), new Vector3(0.762F, 87.312F, 5.102F), new Vector3(0.022F, 0.022F, 0.022F));
AddDisplayRule("ToolbotBody", "Chest", new Vector3(0.064F, 1.168F, 3.419F), new Vector3(0F, 270F, 0F), new Vector3(0.214F, 0.214F, 0.214F));
AddDisplayRule("EngiBody", "HandR", new Vector3(0.026F, -0.123F, 0.048F), new Vector3(275.324F, 252.038F, 18.986F), new Vector3(0.029F, 0.029F, 0.029F));
AddDisplayRule("EngiTurretBody", "Neck", new Vector3(0F, 0.6F, -0.168F), new Vector3(0F, 90F, 0F), new Vector3(0.133F, 0.133F, 0.133F));
AddDisplayRule("EngiWalkerTurretBody", "Neck", new Vector3(0F, 0.533F, -0.168F), new Vector3(0F, 90F, 0F), new Vector3(0.133F, 0.133F, 0.133F));
AddDisplayRule("MageBody", "Chest", new Vector3(0F, 0.064F, -0.327F), new Vector3(0F, 90F, 7.532F), new Vector3(0.039F, 0.039F, 0.039F));
AddDisplayRule("MercBody", "Head", new Vector3(0F, 0.105F, -0.143F), new Vector3(0F, 90F, 19.781F), new Vector3(0.02F, 0.02F, 0.02F));
AddDisplayRule("TreebotBody", "PlatformBase", new Vector3(0.537F, -0.273F, 0.135F), new Vector3(7.036F, 343.597F, 322.203F), new Vector3(0.063F, 0.063F, 0.063F));
AddDisplayRule("LoaderBody", "MechBase", new Vector3(0F, -0.051F, -0.159F), new Vector3(0F, 90F, 0F), new Vector3(0.037F, 0.037F, 0.037F));
AddDisplayRule("CrocoBody", "SpineChest1", new Vector3(-0.951F, 0.633F, -0.312F), new Vector3(4.342F, 131.684F, 70.801F), new Vector3(0.254F, 0.254F, 0.254F));
AddDisplayRule("CaptainBody", "HandL", new Vector3(0.009F, 0.167F, 0.045F), new Vector3(270F, 270F, 0F), new Vector3(0.035F, 0.035F, 0.035F));
AddDisplayRule("BrotherBody", "UpperArmL", BrotherInfection.red, new Vector3(0.124F, 0.177F, -0.056F), new Vector3(80.946F, 113.634F, 258.867F), new Vector3(0.061F, 0.063F, 0.063F));
if (SoftDependencies.SoftDependenciesCore.itemDisplaysSniper)
{
AddDisplayRule("SniperClassicBody", "Chest", new Vector3(0.00102F, 0.07635F, -0.2573F), new Vector3(0F, 90F, 342.5916F), new Vector3(0.04182F, 0.04182F, 0.04182F));
}
AddDisplayRule("RailgunnerBody", "Backpack", new Vector3(0F, 0.4146F, 0.05697F), new Vector3(0F, 90F, 0F), new Vector3(0.02963F, 0.02963F, 0.02963F));
AddDisplayRule("VoidSurvivorBody", "Chest", new Vector3(0.09556F, 0.08424F, 0.189F), new Vector3(18.8347F, 291.3285F, 8.91174F), new Vector3(0.0247F, 0.0247F, 0.0247F));
};
On.RoR2.CharacterBody.Awake += (orig, self) =>
{
orig(self);
self.gameObject.AddComponent <PreDamageShield>();
};
GenericGameEvents.BeforeTakeDamage += (damageInfo, attackerInfo, victimInfo) =>
{
if (!victimInfo.gameObject)
{
return;
}
PreDamageShield preDamageShield = victimInfo.gameObject.GetComponent <PreDamageShield>();
if (preDamageShield && victimInfo.healthComponent)
{
preDamageShield.value = victimInfo.healthComponent.shield;
}
};
GenericGameEvents.OnTakeDamage += (damageReport) =>
{
if (!damageReport.victim)
{
return;
}
PreDamageShield preDamageShield = damageReport.victim.GetComponent <PreDamageShield>();
if (damageReport.victimBody.inventory && damageReport.victimBody.inventory.GetItemCount(itemDef) > 0 && preDamageShield && preDamageShield.value > 0f)
{
/*
* EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/LightningStakeNova"), new EffectData
* {
* origin = characterInfo.body.corePosition,
* scale = radius,
* rotation = Util.QuaternionSafeLookRotation(damageInfo.force)
* }, true);
* BlastAttack blastAttack = new BlastAttack
* {
* position = characterInfo.body.corePosition,
* baseDamage = damageInfo.damage * (4f + (characterInfo.inventory.GetItemCount(itemIndex) - 1)),
* baseForce = damageInfo.force.magnitude,
* radius = radius,
* attacker = characterInfo.gameObject,
* inflictor = null,
* teamIndex = characterInfo.teamIndex,
* crit = damageInfo.crit,
* procChainMask = default(ProcChainMask),
* procCoefficient = 0f,
* damageColorIndex = DamageColorIndex.Item,
* falloffModel = BlastAttack.FalloffModel.None,
* damageType = DamageType.AOE,
* attackerFiltering = AttackerFiltering.NeverHit // don't explode self with Chaos
* };
* blastAttack.Fire();
*/
BullseyeSearch search = new BullseyeSearch
{
searchOrigin = damageReport.victim.transform.position,
searchDirection = Vector3.zero,
teamMaskFilter = TeamMask.allButNeutral
};
search.teamMaskFilter.RemoveTeam(damageReport.victimTeamIndex);
search.filterByLoS = false;
search.sortMode = BullseyeSearch.SortMode.Distance;
search.maxDistanceFilter = radius;
search.RefreshCandidates();
bool crit = damageReport.victimBody.RollCrit();
foreach (HurtBox hurtBox in search.GetResults())
{
LightningOrb lightningOrb = new LightningOrb
{
origin = damageReport.victimBody.corePosition,
damageValue = damageReport.damageDealt * (damage / 100f + damagePerStack / 100f * (damageReport.victimBody.inventory.GetItemCount(itemDef) - 1)),
isCrit = crit,
bouncesRemaining = 0,
teamIndex = damageReport.victimTeamIndex,
attacker = damageReport.victim.gameObject,
procCoefficient = 0f,
lightningType = LightningOrb.LightningType.Ukulele,
damageColorIndex = DamageColorIndex.Item,
range = radius,
target = hurtBox
};
OrbManager.instance.AddOrb(lightningOrb);
}
}
};
RecalculateStatsAPI.GetStatCoefficients += RecalculateStatsAPI_GetStatCoefficients;
}
private static void On_LightningOrbArrival(On.RoR2.Orbs.LightningOrb.orig_OnArrival orig, LightningOrb self)
{
orig(self);
if (self.lightningType != LightningOrb.LightningType.CrocoDisease || Scepter.instance.GetCount(self.attacker?.GetComponent <CharacterBody>()) < 1)
{
return;
}
if (!self.target || !self.target.healthComponent)
{
return;
}
var cpt = self.target.healthComponent.gameObject.GetComponentInChildren <DiseaseWard>()?.gameObject;
if (!cpt)
{
cpt = UnityEngine.Object.Instantiate(diseaseWardPrefab);
cpt.GetComponent <TeamFilter>().teamIndex = self.target.GetComponent <TeamComponent>()?.teamIndex ?? TeamIndex.Monster;
cpt.GetComponent <DiseaseWard>().attacker = self.attacker;
cpt.GetComponent <DiseaseWard>().owner = self.target.healthComponent.gameObject;
cpt.GetComponent <NetworkedBodyAttachment>().AttachToGameObjectAndSpawn(self.target.healthComponent.gameObject);
}
cpt.GetComponent <DiseaseWard>().netDamage = self.damageValue;
}
private static void LightningOrb_Begin(On.RoR2.Orbs.LightningOrb.orig_Begin orig, LightningOrb self)
{
if (self.lightningType == (LightningOrb.LightningType)(-1))
{
EffectData effectData = new EffectData
{
origin = self.origin,
genericFloat = 0.1f
};
effectData.SetHurtBoxReference(self.target);
EffectManager.SpawnEffect(Resources.Load <GameObject>("prefabs/effects/orbeffects/arroworbeffect"), effectData, true);
}
else
{
orig(self);
}
}
public void QueueLightning(LightningOrb lightningOrb, float delay)
{
lightningDelayStopwatch = delay;
queuedLightningOrb = lightningOrb;
}
