// Token: 0x060022CB RID: 8907 RVA: 0x0009710C File Offset: 0x0009530C
public void Update()
{
TeamIndex teamIndex = this.source ? this.source.teamIndex : TeamIndex.Neutral;
float x = 0f;
if (this.source && TeamManager.instance)
{
x = Mathf.InverseLerp(TeamManager.instance.GetTeamCurrentLevelExperience(teamIndex), TeamManager.instance.GetTeamNextLevelExperience(teamIndex), TeamManager.instance.GetTeamExperience(teamIndex));
}
if (this.fillRectTransform)
{
Rect rect = this.rectTransform.rect;
Rect rect2 = this.fillRectTransform.rect;
this.fillRectTransform.anchorMin = new Vector2(0f, 0f);
this.fillRectTransform.anchorMax = new Vector2(x, 1f);
this.fillRectTransform.sizeDelta = new Vector2(1f, 1f);
}
}
// Token: 0x06002197 RID: 8599 RVA: 0x000913FC File Offset: 0x0008F5FC
private void PopulateCharacterDataSet(AllyCardManager.CharacterDataSet characterDataSet)
{
TeamIndex teamIndex = this.FindTargetTeam();
ReadOnlyCollection <CharacterMaster> readOnlyInstancesList = CharacterMaster.readOnlyInstancesList;
for (int i = 0; i < readOnlyInstancesList.Count; i++)
{
CharacterMaster characterMaster = readOnlyInstancesList[i];
if (characterMaster.teamIndex == teamIndex)
{
CharacterBody body = characterMaster.GetBody();
if ((!body || !body.teamComponent || !body.teamComponent.hideAllyCardDisplay) && (!characterMaster.playerCharacterMasterController || characterMaster.playerCharacterMasterController.networkUser) && this.currentSource.master != characterMaster)
{
AllyCardManager.CharacterData characterData = new AllyCardManager.CharacterData(characterMaster);
characterDataSet.Add(ref characterData);
}
}
}
}
private void Start()
{
if (this.removalTime > 0f)
{
this.needsRemovalTime = true;
}
RaycastHit raycastHit;
if (this.floorWard && Physics.Raycast(base.transform.position, Vector3.down, out raycastHit, 500f, LayerIndex.world.mask))
{
base.transform.position = raycastHit.point;
base.transform.up = raycastHit.normal;
}
if (this.rangeIndicator && this.expires)
{
ScaleParticleSystemDuration component = this.rangeIndicator.GetComponent <ScaleParticleSystemDuration>();
if (component)
{
component.newDuration = this.expireDuration;
}
}
if (NetworkServer.active)
{
float radiusSqr = this.calculatedRadius * this.calculatedRadius;
Vector3 position = base.transform.position;
if (this.invertTeamFilter)
{
for (TeamIndex teamIndex = TeamIndex.Neutral; teamIndex < TeamIndex.Count; teamIndex += 1)
{
if (teamIndex != this.teamFilter.teamIndex)
{
this.BuffTeam(TeamComponent.GetTeamMembers(teamIndex), radiusSqr, position);
}
}
return;
}
this.BuffTeam(TeamComponent.GetTeamMembers(this.teamFilter.teamIndex), radiusSqr, position);
}
}
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;
damageInfo.procChainMask.SetProcValue(ProcType.Rings, true);
GameObject gameObject = Resources.Load <GameObject>("Prefabs/Projectiles/FireTornado");
float resetInterval = gameObject.GetComponent <ProjectileOverlapAttack>().resetInterval;
float lifetime = gameObject.GetComponent <ProjectileSimple>().lifetime;
float damageCoefficient1 = (float)(2.5 + 2.5 * (double)itemCount);
float DamageProjectile = Util.OnHitProcDamage(damageInfo.damage, Attacker.damage, damageCoefficient1) / lifetime * resetInterval;
float ProjectileSpeed = 0.0f;
Quaternion quaternion = Quaternion.identity;
Vector3 forward1 = damageInfo.position - aimOrigin;
forward1.y = 0.0f;
if (forward1 != Vector3.zero)
{
ProjectileSpeed = -1f;
quaternion = Util.QuaternionSafeLookRotation(forward1, Vector3.up);
}
ProjectileManager.instance.FireProjectile(new FireProjectileInfo()
{
damage = DamageProjectile,
crit = damageInfo.crit,
damageColorIndex = DamageColorIndex.Item,
position = damageInfo.position,
procChainMask = damageInfo.procChainMask,
force = 0.0f,
owner = damageInfo.attacker,
projectilePrefab = gameObject,
rotation = quaternion,
speedOverride = ProjectileSpeed,
target = null
});
}
// Token: 0x06000E51 RID: 3665 RVA: 0x00046790 File Offset: 0x00044990
public void SpawnDamageNumber(float amount, Vector3 position, bool crit, TeamIndex teamIndex, DamageColorIndex damageColorIndex)
{
Color a = DamageColor.FindColor(damageColorIndex);
Color white = Color.white;
if (teamIndex == TeamIndex.Monster)
{
white = new Color(0.5568628f, 0.29411766f, 0.6039216f);
}
this.ps.Emit(new ParticleSystem.EmitParams
{
position = position,
startColor = a * white,
applyShapeToPosition = true
}, 1);
this.ps.GetCustomParticleData(this.customData, ParticleSystemCustomData.Custom1);
this.customData[this.customData.Count - 1] = new Vector4(1f, 0f, amount, crit ? 1f : 0f);
this.ps.SetCustomParticleData(this.customData, ParticleSystemCustomData.Custom1);
}
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;
List <HealthComponent> healthComponentList = new List <HealthComponent>()
{
victim.GetComponent <HealthComponent>()
};
float damageCoefficient = 1f;
float num3 = Util.OnHitProcDamage(damageInfo.damage, Attacker.damage, damageCoefficient);
for (int index = 0; index < 5 + itemCount * 5; ++index)
{
BounceOrb bounceOrb = new BounceOrb
{
origin = damageInfo.position,
damageValue = num3,
isCrit = damageInfo.crit,
teamIndex = attackerTeamIndex,
attacker = damageInfo.attacker,
procChainMask = damageInfo.procChainMask
};
bounceOrb.procChainMask.AddProc(ProcType.BounceNearby);
bounceOrb.procCoefficient = 0.33f;
bounceOrb.damageColorIndex = DamageColorIndex.Item;
bounceOrb.bouncedObjects = healthComponentList;
HurtBox hurtBox = bounceOrb.PickNextTarget(victim.transform.position, 30f);
if ((bool)hurtBox)
{
bounceOrb.target = hurtBox;
OrbManager.instance.AddOrb(bounceOrb);
}
}
}
public override bool Effect(EquipmentSlot slot)
{
var ownerBody = slot.GetComponent <CharacterBody>();
Vector3 pos = Util.GetCorePosition(ownerBody);
for (TeamIndex teamIndex = TeamIndex.Neutral; teamIndex < TeamIndex.Count; teamIndex++)
{
if (teamIndex != ownerBody.teamComponent.teamIndex)
{
foreach (TeamComponent teamComponent in TeamComponent.GetTeamMembers(teamIndex))
{
if ((teamComponent.transform.position - pos).sqrMagnitude <= Mathf.Pow(Radius, 2))
{
CharacterBody component = teamComponent.GetComponent <CharacterBody>();
if (component)
{
var state = component.GetComponent <SetStateOnHurt>();
if (state)
{
state.SetFrozen(FreezeDuration);
}
}
}
}
}
}
GameObject explosionPreFab = UnityEngine.Object.Instantiate(Resources.Load <GameObject>("Prefabs/NetworkedObjects/GenericDelayBlast"), pos, Quaternion.identity);
explosionPreFab.transform.localScale = new Vector3(Radius, Radius, Radius);
DelayBlast delayBlast = explosionPreFab.GetComponent <DelayBlast>();
delayBlast.explosionEffect = Resources.Load <GameObject>("Prefabs/Effects/ImpactEffects/AffixWhiteExplosion");
delayBlast.delayEffect = Resources.Load <GameObject>("Prefabs/Effects/AffixWhiteDelayEffect");
delayBlast.position = pos;
delayBlast.baseDamage = 0;
delayBlast.baseForce = 0f;
delayBlast.radius = Radius;
delayBlast.maxTimer = 0.1f;
delayBlast.procCoefficient = 0f;
return(true);
}
private static void RitualDagger_OnKill(On.RoR2.GlobalEventManager.orig_OnCharacterDeath orig, GlobalEventManager gem,
DamageReport damageReport)
{
try
{
if (damageReport.damageInfo.attacker)
{
Inventory Inv = damageReport.damageInfo.attacker.GetComponent <CharacterBody>().inventory;
int RitualDaggerCount = Inv.GetItemCount(GNCItemSuite.RitualDaggerItemIndex);
if (RitualDaggerCount > 0)
{
CharacterBody component = damageReport.damageInfo.attacker.GetComponent <CharacterBody>();
TeamComponent component2 = component.GetComponent <TeamComponent>();
TeamIndex teamIndex = component2 ? component2.teamIndex : TeamIndex.Neutral;
if (component)
{
CharacterMaster master = component.master;
if (master)
{
if ((RitualDaggerCount + GNCItemSuiteConfig.RitualDaggerProcChance.Value) >=
UnityEngine.Random.Range(0, 100))
{
ProcMissile(RitualDaggerCount, component, master, teamIndex,
damageReport.damageInfo.procChainMask, null, damageReport.damageInfo);
for (var i = 0; i < RitualDaggerCount; i += 2)
{
ProcMissile(RitualDaggerCount, component, master, teamIndex,
damageReport.damageInfo.procChainMask, null, damageReport.damageInfo);
}
}
}
}
}
}
}
catch
{
}
orig(gem, damageReport);
}
private bool AddAditionalLinks(CharacterBody cb)
{
#if DEBUG
TurboEdition._logger.LogWarning(EquipmentName + ": doing additional links.");
#endif
TeamIndex ownerTeam = cb.teamComponent.teamIndex;
for (TeamIndex teamCounter = TeamIndex.Neutral; teamCounter < TeamIndex.Count; teamCounter++)
{
if (TeamManager.IsTeamEnemy(ownerTeam, teamCounter))
{
var enemyMember = TeamComponent.GetTeamMembers(teamCounter);
if (teamCounter != TeamIndex.Neutral && enemyMember.Count <= 0)
{
return(false);
} //It's gonna be hilarious if some enemies will link to barrels and pots
#if DEBUG
TurboEdition._logger.LogWarning(EquipmentName + ": got enemy teams to activator's.");
#endif
int link = 0;
for (int i = 0; i < enemyMember.Count && link < sphereSearchCount; i++)
{
#if DEBUG
TurboEdition._logger.LogWarning(EquipmentName + ": doing extra links " + link + 1 + " out of " + sphereSearchCount);
#endif
GameObject linkComponent = enemyMember[i].body.GetComponentInChildren <LinkComponent>()?.gameObject;
//Check if they are already being linked and generate a sphere search on them to get additional targets
if (linkComponent && NetworkServer.active)
{
#if DEBUG
TurboEdition._logger.LogWarning(EquipmentName + ": server is active and someone in the enemy team has a LinkComponent, generating extra SphereSearch within them.");
#endif
GenerateSphereSearch(enemyMember[i].body, true);
link++;
}
}
return(true);
}
}
return(false);
}
public override void Begin()
{
duration = distanceToTarget / 30f;
EffectData effectData = new EffectData
{
origin = origin,
genericFloat = duration
};
effectData.SetHurtBoxReference(target);
EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/OrbEffects/DevilOrbEffect"), effectData, true);
targetBody = target.healthComponent.body;
targetTeam = target.teamIndex;
targetTeamManager = new TeamManager();
if (targetBody)
{
targetInventory = targetBody.inventory;
targetHealth = targetBody.healthComponent;
}
}
// Token: 0x0600162D RID: 5677 RVA: 0x0006A228 File Offset: 0x00068428
private void OnJoinTeam(TeamIndex newTeamIndex)
{
if (TeamComponent.TeamIsValid(newTeamIndex))
{
TeamComponent.teamsList[(int)newTeamIndex].Add(this);
}
this.SetupIndicator();
HurtBoxGroup hurtBoxGroup = this.hurtBoxGroup;
HurtBox[] array = (hurtBoxGroup != null) ? hurtBoxGroup.hurtBoxes : null;
if (array != null)
{
HurtBox[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
array2[i].teamIndex = newTeamIndex;
}
}
this.oldTeamIndex = newTeamIndex;
}
// Token: 0x06002FD7 RID: 12247 RVA: 0x000CCF68 File Offset: 0x000CB168
public override void OnEnter()
{
base.OnEnter();
this.highestFallSpeed = 0f;
if (base.isAuthority)
{
if (this.body)
{
TeamMask allButNeutral = TeamMask.allButNeutral;
TeamIndex objectTeam = TeamComponent.GetObjectTeam(this.bodyGameObject);
if (objectTeam != TeamIndex.None)
{
allButNeutral.RemoveTeam(objectTeam);
}
BullseyeSearch bullseyeSearch = new BullseyeSearch();
bullseyeSearch.filterByLoS = true;
bullseyeSearch.maxDistanceFilter = 300f;
bullseyeSearch.maxAngleFilter = HeadstompersFall.seekCone;
bullseyeSearch.searchOrigin = this.body.footPosition;
bullseyeSearch.searchDirection = Vector3.down;
bullseyeSearch.sortMode = BullseyeSearch.SortMode.Angle;
bullseyeSearch.teamMaskFilter = allButNeutral;
bullseyeSearch.viewer = this.body;
bullseyeSearch.RefreshCandidates();
HurtBox hurtBox = bullseyeSearch.GetResults().FirstOrDefault <HurtBox>();
this.seekTransform = ((hurtBox != null) ? hurtBox.transform : null);
GameObject gameObject;
if (hurtBox == null)
{
gameObject = null;
}
else
{
HealthComponent healthComponent = hurtBox.healthComponent;
gameObject = ((healthComponent != null) ? healthComponent.gameObject : null);
}
this.seekBodyObject = gameObject;
}
this.SetOnHitGroundProvider(this.bodyMotor);
}
}
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;
Vector3 position = damageInfo.position;
Vector3 forward = characterBody.corePosition - position;
Quaternion rotation = forward.magnitude != 0.0 ? Util.QuaternionSafeLookRotation(forward) : UnityEngine.Random.rotationUniform;
float damageCoefficient = (float)(1.25 + 1.25 * itemCount);
float damage = Util.OnHitProcDamage(damageInfo.damage, Attacker.damage, damageCoefficient);
#pragma warning disable CS0618 // Obsolete Warning Ignore
ProjectileManager.instance.FireProjectile(Resources.Load <GameObject>("Prefabs/Projectiles/StickyBomb"), position, rotation, damageInfo.attacker, damage, 100f, damageInfo.crit, DamageColorIndex.Item, (GameObject)null, forward.magnitude * 60f);
#pragma warning restore CS0618
}
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);
}
}
}
}
// Token: 0x06000E5F RID: 3679 RVA: 0x00046EA4 File Offset: 0x000450A4
private void OnKilled(DamageInfo damageInfo)
{
CharacterBody component = base.GetComponent <CharacterBody>();
EffectManager.instance.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/CoinEmitter"), new EffectData
{
origin = base.transform.position,
genericFloat = this.goldReward,
scale = (component ? component.radius : 1f)
}, true);
if (damageInfo.attacker)
{
TeamComponent component2 = base.GetComponent <TeamComponent>();
CharacterBody component3 = damageInfo.attacker.GetComponent <CharacterBody>();
if (component3)
{
CharacterMaster master = component3.master;
TeamIndex objectTeam = TeamComponent.GetObjectTeam(component3.gameObject);
TeamManager.instance.GiveTeamMoney(objectTeam, this.goldReward);
float num = 1f;
if (component2)
{
num = 1f + (TeamManager.instance.GetTeamLevel(component2.teamIndex) - 1f) * 0.3f;
}
ExperienceManager.instance.AwardExperience(base.transform.position, component3.GetComponent <CharacterBody>(), (ulong)((uint)(this.expReward * num)));
}
if (this.logUnlockableName != "" && Run.instance.selectedDifficulty > DifficultyIndex.Easy && Run.instance.CanUnlockableBeGrantedThisRun(this.logUnlockableName))
{
CharacterBody component4 = base.GetComponent <CharacterBody>();
if (Util.CheckRoll((component4 && component4.isChampion) ? 3f : 1f, component3.master))
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/NetworkedObjects/LogPickup"), base.transform.position, UnityEngine.Random.rotation);
gameObject.GetComponentInChildren <UnlockPickup>().unlockableName = this.logUnlockableName;
gameObject.GetComponent <TeamFilter>().teamIndex = TeamIndex.Player;
NetworkServer.Spawn(gameObject);
}
}
}
}
public void Activate(float damage, float duration, float velocity, TeamIndex team, Sprite image)
{
this.reset();
//set bullet stats
this.Damage = damage;
this.duration = duration;
//set bullet layer
#region Layer
switch (team)
{
case TeamIndex.ONE:
this.gameObject.layer = GameSettings.TeamOneBulletLayer;
break;
case TeamIndex.TWO:
this.gameObject.layer = GameSettings.TeamTwoBulletLayer;
break;
case TeamIndex.THREE:
this.gameObject.layer = GameSettings.TeamThreeBulletLayer;
break;
case TeamIndex.FOUR:
this.gameObject.layer = GameSettings.TeamFourBulletLayer;
break;
}
#endregion Layer
//set bullet image and collider
this.renderer.sprite = image;
this.collider.radius = this.renderer.bounds.extents.x < this.renderer.bounds.extents.y ? this.renderer.bounds.extents.x : this.renderer.bounds.extents.y;
//accelerate bullet
this.rigidBody.velocity = this.transform.up * velocity;
//set this bullet up to be destroyed after its duration elapses
Invoke("Kill", this.duration);
}
// Token: 0x06000473 RID: 1139 RVA: 0x00012B80 File Offset: 0x00010D80
private void HealOccupants(float radius, float healPoints, float healFraction)
{
IEnumerable <Collider> source = Physics.OverlapSphere(base.transform.position, radius, LayerIndex.entityPrecise.mask);
TeamIndex teamIndex = this.teamFilter ? this.teamFilter.teamIndex : TeamIndex.None;
IEnumerable <HealthComponent> source2 = source.Select(new Func <Collider, HealthComponent>(DroneProjectileHoverHeal.SelectHealthComponent));
Func <HealthComponent, bool> < > 9__0;
Func <HealthComponent, bool> predicate;
if ((predicate = < > 9__0) == null)
{
predicate = (< > 9__0 = ((HealthComponent healthComponent) => healthComponent && healthComponent.body.teamComponent.teamIndex == teamIndex));
}
foreach (HealthComponent healthComponent2 in source2.Where(predicate).Distinct <HealthComponent>())
{
float num = healPoints + healthComponent2.fullHealth * healFraction;
if (num > 0f)
{
healthComponent2.Heal(num, default(ProcChainMask), true);
}
}
}
// Token: 0x0600210C RID: 8460 RVA: 0x0009B4FB File Offset: 0x000996FB
static CombatHealthBarViewer()
{
GlobalEventManager.onClientDamageNotified += delegate(DamageDealtMessage msg)
{
if (!msg.victim || msg.isSilent)
{
return;
}
HealthComponent component = msg.victim.GetComponent <HealthComponent>();
if (!component || component.dontShowHealthbar)
{
return;
}
TeamIndex objectTeam = TeamComponent.GetObjectTeam(component.gameObject);
foreach (CombatHealthBarViewer combatHealthBarViewer in CombatHealthBarViewer.instancesList)
{
if (msg.attacker == combatHealthBarViewer.viewerBodyObject && combatHealthBarViewer.viewerBodyObject)
{
combatHealthBarViewer.HandleDamage(component, objectTeam);
}
}
};
}
// Token: 0x06000D1E RID: 3358 RVA: 0x00040DA8 File Offset: 0x0003EFA8
private void UpdateForCamera(CameraRigController cameraRigController)
{
this.visibility = VisibilityLevel.Visible;
bool flag = false;
float target = 1f;
if (this.body)
{
if (flag)
{
target = 0f;
}
if (this.body.HasBuff(BuffIndex.Cloak))
{
TeamIndex teamIndex = TeamIndex.Neutral;
TeamComponent component = this.body.GetComponent <TeamComponent>();
if (component)
{
teamIndex = component.teamIndex;
}
this.visibility = ((cameraRigController.targetTeamIndex == teamIndex) ? VisibilityLevel.Revealed : VisibilityLevel.Cloaked);
}
}
this.firstPersonFade = Mathf.MoveTowards(this.firstPersonFade, target, Time.deltaTime / 0.25f);
this.fade *= this.firstPersonFade;
if (this.fade <= 0f || this.invisibilityCount > 0)
{
this.visibility = VisibilityLevel.Invisible;
}
this.UpdateOverlays();
if (this.materialsDirty)
{
this.UpdateMaterials();
this.materialsDirty = false;
}
}
private static void CCChangeTeam(ConCommandArgs args)
{
string teamString = ArgsHelper.GetValue(args.userArgs, 0);
string playerString = ArgsHelper.GetValue(args.userArgs, 1);
NetworkUser player = GetNetUserFromString(playerString);
player = player ?? args.sender;
TeamIndex teamIndex = TeamIndex.Player;
if (Enum.TryParse(teamString, true, out teamIndex))
{
if ((int)teamIndex >= (int)TeamIndex.None && (int)teamIndex < (int)TeamIndex.Count)
{
Debug.Log("Changed to team " + teamIndex);
if (player.master.GetBody())
{
player.master.GetBody().teamComponent.teamIndex = teamIndex;
player.master.teamIndex = teamIndex;
}
}
}
}
// Token: 0x06000C12 RID: 3090 RVA: 0x0003BE4C File Offset: 0x0003A04C
private Transform FindTarget()
{
TeamIndex teamIndex = TeamIndex.Monster;
TeamIndex teamIndex2 = this.teamFilter.teamIndex;
if (teamIndex2 != TeamIndex.Player)
{
if (teamIndex2 == TeamIndex.Monster)
{
teamIndex = TeamIndex.Player;
}
}
else
{
teamIndex = TeamIndex.Monster;
}
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(teamIndex);
float num = 99999f;
Transform result = null;
Vector3 position = this.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
Transform transform = teamMembers[i].transform;
if (!this.pastTargetList.Contains(transform) || (this.canBounceToSameTarget && transform != this.lastTarget))
{
float num2 = Vector3.SqrMagnitude(transform.position - position);
if (num2 < num && (!this.smartSeeking || !Physics.Raycast(position, transform.position - position, Mathf.Sqrt(num2), LayerIndex.world.mask)) && num2 <= this.maxChainDistance * this.maxChainDistance)
{
num = num2;
result = transform;
}
}
}
return(result);
}
static void AnnounceWinningTeam(TeamIndex teamIndex)
{
string teamText = "";
string resultText = "But can they keep it up?";
string conclusionText = "Head towards the teleporter for the next round.";
switch (teamIndex)
{
case TeamIndex.Player:
teamText = "Team 1";
break;
case TeamIndex.Neutral:
teamText = "Team 2";
break;
case TeamIndex.Monster:
teamText = "Team 3";
break;
default:
teamText = "No real player";
resultText = "It's a draw!";
conclusionText = "Teleporting...";
break;
}
Chat.SendBroadcastChat(new Chat.SimpleChatMessage
{
baseToken = Util.GenerateColoredString(teamText, new Color32(76, byte.MaxValue, 0, byte.MaxValue)) + " has survived... " + resultText
});
Chat.SendBroadcastChat(new Chat.SimpleChatMessage
{
baseToken = Util.GenerateColoredString(conclusionText, new Color32(0, 255, 255, 255))
});
}
private void AddDot(GameObject attackerObject, float duration, DotController.DotIndex dotIndex, float damageMultiplier)
{
if (!NetworkServer.active)
{
Debug.LogWarning("[Server] function 'System.Void RoR2.DotController::AddDot(UnityEngine.GameObject,System.Single,RoR2.DotController/DotIndex,System.Single)' called on client");
return;
}
if (dotIndex < DotController.DotIndex.Bleed || dotIndex >= DotController.DotIndex.Count)
{
return;
}
TeamIndex teamIndex = TeamIndex.Neutral;
float num = 0f;
TeamComponent component = attackerObject.GetComponent <TeamComponent>();
if (component)
{
teamIndex = component.teamIndex;
}
CharacterBody component2 = attackerObject.GetComponent <CharacterBody>();
if (component2)
{
num = component2.damage;
}
DotController.DotDef dotDef = DotController.dotDefs[(int)dotIndex];
DotController.DotStack dotStack = new DotController.DotStack
{
dotIndex = dotIndex,
dotDef = dotDef,
attackerObject = attackerObject,
attackerTeam = teamIndex,
timer = duration,
damage = dotDef.damageCoefficient * num * damageMultiplier,
damageType = DamageType.Generic
};
switch (dotIndex)
{
case DotController.DotIndex.Helfire:
{
if (!component2)
{
return;
}
HealthComponent healthComponent = component2.healthComponent;
if (!healthComponent)
{
return;
}
dotStack.damage = healthComponent.fullHealth * 0.01f * damageMultiplier;
if (this.victimObject == attackerObject)
{
dotStack.damageType |= (DamageType.NonLethal | DamageType.Silent);
}
else if (this.victimTeam == teamIndex)
{
dotStack.damage *= 0.5f;
}
else
{
dotStack.damage *= 24f;
}
int i = 0;
int count = this.dotStackList.Count;
while (i < count)
{
if (this.dotStackList[i].dotIndex == DotController.DotIndex.Helfire && this.dotStackList[i].attackerObject == attackerObject)
{
this.dotStackList[i].timer = Mathf.Max(this.dotStackList[i].timer, duration);
this.dotStackList[i].damage = dotStack.damage;
return;
}
i++;
}
if (this.victimBody)
{
EffectManager.SpawnEffect(Resources.Load <GameObject>("Prefabs/Effects/HelfireIgniteEffect"), new EffectData
{
origin = this.victimBody.corePosition
}, true);
}
break;
}
case DotController.DotIndex.PercentBurn:
dotStack.damage = Mathf.Min(dotStack.damage, this.victimBody.healthComponent.fullCombinedHealth * 0.01f);
break;
case DotController.DotIndex.Poison:
{
float a = this.victimHealthComponent.fullCombinedHealth / 100f * 1f * dotDef.interval;
dotStack.damage = Mathf.Min(Mathf.Max(a, dotStack.damage), dotStack.damage * 50f);
dotStack.damageType = DamageType.NonLethal;
int j = 0;
int count2 = this.dotStackList.Count;
while (j < count2)
{
if (this.dotStackList[j].dotIndex == DotController.DotIndex.Poison)
{
this.dotStackList[j].timer = Mathf.Max(this.dotStackList[j].timer, duration);
this.dotStackList[j].damage = dotStack.damage;
return;
}
j++;
}
bool flag = false;
for (int k = 0; k < this.dotStackList.Count; k++)
{
if (this.dotStackList[k].dotIndex == DotController.DotIndex.Poison)
{
flag = true;
break;
}
}
if (!flag && component2 != null)
{
CharacterMaster master = component2.master;
if (master != null)
{
PlayerStatsComponent playerStatsComponent = master.playerStatsComponent;
if (playerStatsComponent != null)
{
playerStatsComponent.currentStats.PushStatValue(StatDef.totalCrocoInfectionsInflicted, 1UL);
}
}
}
break;
}
}
this.dotStackList.Add(dotStack);
this.OnDotStackAddedServer(dotStack);
}
private static void CCSpawnAI(ConCommandArgs args)
{
GameObject prefab;
GameObject body;
GameObject gameObject = null;
string prefabString = ArgsHelper.GetValue(args.userArgs, 0);
string eliteString = ArgsHelper.GetValue(args.userArgs, 1);
string teamString = ArgsHelper.GetValue(args.userArgs, 2);
string braindeadString = ArgsHelper.GetValue(args.userArgs, 3);
string bodyString = GetBodyMasterLink(prefabString, 0); //prefabString.Replace("Master", "");
string masterString = GetBodyMasterLink(prefabString, 1); //prefabString.Replace("Body", "");
prefab = MasterCatalog.FindMasterPrefab(masterString);
body = BodyCatalog.FindBodyPrefab(bodyString);
if (prefab == null)
{
List <string> array = new List <string>();
foreach (var item in MasterCatalog.allMasters)
{
array.Add(item.name);
}
string list = string.Join("\n", array);
Debug.LogFormat("Could not spawn {0}, Try: spawn_ai GolemBody --- \n{1}", prefabString, list);
return;
}
gameObject = Instantiate <GameObject>(prefab, args.sender.master.GetBody().transform.position, Quaternion.identity);
CharacterMaster master = gameObject.GetComponent <CharacterMaster>();
NetworkServer.Spawn(gameObject);
master.SpawnBody(body, args.sender.master.GetBody().transform.position, Quaternion.identity);
EliteIndex eliteIndex = EliteIndex.None;
if (Enum.TryParse <EliteIndex>(eliteString, true, out eliteIndex))
{
if ((int)eliteIndex > (int)EliteIndex.None && (int)eliteIndex < (int)EliteIndex.Count)
{
master.inventory.SetEquipmentIndex(EliteCatalog.GetEliteDef(eliteIndex).eliteEquipmentIndex);
}
}
TeamIndex teamIndex = TeamIndex.Neutral;
if (Enum.TryParse <TeamIndex>(teamString, true, out teamIndex))
{
if ((int)teamIndex >= (int)TeamIndex.None && (int)teamIndex < (int)TeamIndex.Count)
{
master.teamIndex = teamIndex;
}
}
bool braindead;
if (bool.TryParse(braindeadString, out braindead))
{
if (braindead)
{
Destroy(master.GetComponent <BaseAI>());
}
}
Debug.Log("Attempting to spawn " + prefabString);
}
public static uint GetTeamLevel(TeamIndex team = TeamIndex.Player)
{
return(TeamManager.instance?.GetTeamLevel(team) ?? 0);
}
// Token: 0x060009BB RID: 2491 RVA: 0x00030CF8 File Offset: 0x0002EEF8
public static void Write(this NetworkWriter writer, TeamIndex teamIndex)
{
byte value = (byte)(teamIndex + 1);
writer.Write(value);
}
// Token: 0x06001450 RID: 5200 RVA: 0x000569B4 File Offset: 0x00054BB4
public static bool IsTeamEnemy(TeamIndex teamA, TeamIndex teamB)
{
return(teamA != teamB);
}
// Token: 0x06002BFB RID: 11259 RVA: 0x000B9D18 File Offset: 0x000B7F18
public HealPulse(Vector3 origin, float finalRadius, float healFractionValue, float duration, TeamIndex teamIndex)
{
this.sphereSearch = new SphereSearch
{
mask = LayerIndex.entityPrecise.mask,
origin = origin,
queryTriggerInteraction = QueryTriggerInteraction.Collide,
radius = 0f
};
this.finalRadius = finalRadius;
this.healFractionValue = healFractionValue;
this.rate = 1f / duration;
this.teamMask = default(TeamMask);
this.teamMask.AddTeam(teamIndex);
}
// Token: 0x06002E87 RID: 11911 RVA: 0x000C5B08 File Offset: 0x000C3D08
private void FireBeamServer(Ray aimRay, GameObject tracerEffectPrefab, float maxDistance, bool isInitialBeam)
{
bool didHit = false;
BulletAttack bulletAttack = new BulletAttack
{
origin = aimRay.origin,
aimVector = aimRay.direction,
bulletCount = 1U,
damage = base.GetDamage() * FireMainBeamState.mainBeamDamageCoefficient,
damageColorIndex = DamageColorIndex.Item,
damageType = DamageType.Generic,
falloffModel = BulletAttack.FalloffModel.None,
force = FireMainBeamState.mainBeamForce,
hitEffectPrefab = FireMainBeamState.mainBeamImpactEffect,
HitEffectNormal = false,
hitMask = LayerIndex.entityPrecise.mask,
isCrit = this.isCrit,
maxDistance = maxDistance,
minSpread = 0f,
maxSpread = 0f,
muzzleName = "",
owner = base.ownerBody.gameObject,
procChainMask = default(ProcChainMask),
procCoefficient = FireMainBeamState.mainBeamProcCoefficient,
queryTriggerInteraction = QueryTriggerInteraction.UseGlobal,
radius = FireMainBeamState.mainBeamRadius,
smartCollision = true,
sniper = false,
spreadPitchScale = 1f,
spreadYawScale = 1f,
stopperMask = LayerIndex.world.mask,
tracerEffectPrefab = (isInitialBeam ? tracerEffectPrefab : null),
weapon = base.gameObject
};
TeamIndex teamIndex = base.ownerBody.teamComponent.teamIndex;
bulletAttack.hitCallback = delegate(ref BulletAttack.BulletHit info)
{
bool flag = bulletAttack.DefaultHitCallback(ref info);
if (!isInitialBeam)
{
return(true);
}
if (flag)
{
HealthComponent healthComponent = info.hitHurtBox ? info.hitHurtBox.healthComponent : null;
if (healthComponent && healthComponent.alive && info.hitHurtBox.teamIndex != teamIndex)
{
flag = false;
}
}
if (!flag)
{
didHit = true;
this.beamHitPosition = info.point;
}
return(flag);
};
bulletAttack.Fire();
if (!didHit)
{
RaycastHit raycastHit;
if (Physics.Raycast(aimRay, out raycastHit, FireMainBeamState.mainBeamMaxDistance, LayerIndex.world.mask, QueryTriggerInteraction.Ignore))
{
didHit = true;
this.beamHitPosition = raycastHit.point;
}
else
{
this.beamHitPosition = aimRay.GetPoint(FireMainBeamState.mainBeamMaxDistance);
}
}
if (didHit & isInitialBeam)
{
FireProjectileInfo fireProjectileInfo = default(FireProjectileInfo);
fireProjectileInfo.projectilePrefab = FireMainBeamState.secondBombPrefab;
fireProjectileInfo.owner = base.ownerBody.gameObject;
fireProjectileInfo.position = this.beamHitPosition - aimRay.direction * 0.5f;
fireProjectileInfo.rotation = Quaternion.identity;
fireProjectileInfo.damage = base.GetDamage() * FireMainBeamState.secondBombDamageCoefficient;
fireProjectileInfo.damageColorIndex = DamageColorIndex.Item;
fireProjectileInfo.crit = this.isCrit;
ProjectileManager.instance.FireProjectile(fireProjectileInfo);
}
if (!isInitialBeam)
{
EffectData effectData = new EffectData
{
origin = aimRay.origin,
start = base.transform.position
};
effectData.SetNetworkedObjectReference(base.gameObject);
EffectManager.SpawnEffect(tracerEffectPrefab, effectData, true);
}
}
