// Token: 0x06002099 RID: 8345 RVA: 0x000996F0 File Offset: 0x000978F0
private void Update()
{
TeamIndex teamIndex = TeamIndex.None;
TeamComponent teamComponent = null;
if (this.sourceGameObject)
{
teamComponent = this.sourceGameObject.GetComponent <TeamComponent>();
if (teamComponent)
{
teamIndex = teamComponent.teamIndex;
}
}
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(teamIndex);
int num = teamMembers.Count;
if (teamComponent && teamMembers.Contains(teamComponent))
{
num--;
}
this.cardAllocator.AllocateElements(num);
int i = 0;
int num2 = 0;
while (i < teamMembers.Count)
{
GameObject gameObject = teamMembers[i].gameObject;
if (gameObject != this.sourceGameObject)
{
this.cardAllocator.elements[num2++].sourceGameObject = gameObject;
}
i++;
}
}
public void UpdateDroneInventories(int difference)
{
var master = body.master;
if (master)
{
foreach (var otherBody in TeamComponent.GetTeamMembers(master.teamIndex).Select(x => x.body).Where(x => x != null))
{
if (otherBody.bodyFlags.HasFlag(CharacterBody.BodyFlags.Mechanical) && otherBody.master && otherBody.inventory)
{
var minionOwnership = otherBody.master.minionOwnership;
if (minionOwnership && minionOwnership.ownerMaster == master)
{
if (difference > 0)
{
otherBody.inventory.GiveItem(MysticsItemsContent.Items.MysticsItems_DroneWires, difference);
}
else if (difference < 0)
{
otherBody.inventory.RemoveItem(MysticsItemsContent.Items.MysticsItems_DroneWires, -difference);
}
}
}
}
}
}
private void DoPassive()
{
if (!NetworkServer.active)
{
return;
}
checkPassiveStopWatch += Time.fixedDeltaTime;
if (checkPassiveStopWatch > checkPassiveInterval)
{
checkPassiveStopWatch = 0f;
if (this.body)
{
int buffCounts = 0;
var allies = TeamComponent.GetTeamMembers(TeamIndex.Player);
foreach (var ally in allies)
{
var allyBody = ally.body;
if (allyBody && allyBody != this.body &&
(Vector3.Distance(allyBody.transform.position, this.body.transform.position) <= GurrenController.passiveDistance))
{
buffCounts++;
}
}
this.body.SetBuffCount(Buffs.kaminaBuff.buffIndex, buffCounts);
}
}
}
private void ServerProc()
{
List <TeamComponent> teamMembers = new List <TeamComponent>();
bool isFF = FriendlyFireManager.friendlyFireMode != FriendlyFireManager.FriendlyFireMode.Off;
if (isFF || teamFilter.teamIndex != TeamIndex.Monster)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Monster));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Neutral)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Neutral));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Player)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Player));
}
float sqrad = radius * radius;
teamMembers.Remove(owner.GetComponent <TeamComponent>());
foreach (TeamComponent tcpt in teamMembers)
{
if ((tcpt.transform.position - transform.position).sqrMagnitude <= sqrad)
{
if (tcpt.body && tcpt.body.mainHurtBox && tcpt.body.isActiveAndEnabled && damage > 0f)
{
OrbManager.instance.AddOrb(new BarbedWireOrb {
attacker = owner,
bouncesRemaining = 0,
damageColorIndex = DamageColorIndex.Bleed,
damageType = DamageType.AOE,
damageValue = damage,
isCrit = false,
origin = transform.position,
procChainMask = default,
private void GlobalEventManager_OnTeamLevelUp(On.RoR2.GlobalEventManager.orig_OnTeamLevelUp orig, TeamIndex teamIndex)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(teamIndex);
for (int i = 0; i < teamMembers.Count; i++)
{
TeamComponent teamComponent = teamMembers[i];
if (teamComponent)
{
CharacterBody characterBody = teamComponent.GetComponent <CharacterBody>();
if (characterBody)
{
CharacterMaster master = characterBody.master;
if (master)
{
int nokiaItemCount = master.inventory.GetItemCount(Nokia.itemIndex);
//int ancientItemCount = master.inventory.GetItemCount(BrokenScepter.itemIndex);
if (nokiaItemCount > 0 && NetworkServer.active && Util.CheckRoll(50, master))
{
NokiaCall(characterBody.transform, nokiaItemCount);
}
}
}
}
}
orig(teamIndex);
}
public static GameObject GetMostHurtTeam(TeamIndex teamIndex)
{
ReadOnlyCollection <TeamComponent> teamComponents = TeamComponent.GetTeamMembers(teamIndex);
//Dictionary<TeamComponent, float> keyValuePairs = new Dictionary<TeamComponent, float>();
var lowestHealthFraction = 1f;
GameObject lowestHealthObject = null;
foreach (var ally in teamComponents)
{
if (ally.body?.healthComponent)
{
//keyValuePairs.Add(ally, ally.body.healthComponent.health / ally.body.healthComponent.fullHealth);
var calculatedHealthFraction = ally.body.healthComponent.health / ally.body.healthComponent.fullHealth;
if (calculatedHealthFraction < lowestHealthFraction)
{
lowestHealthFraction = calculatedHealthFraction;
lowestHealthObject = ally.body.gameObject;
}
}
}
return(lowestHealthObject);
// https://stackoverflow.com/questions/23734686/c-sharp-dictionary-get-the-key-of-the-min-value
/*if (keyValuePairs.Count > 0)
* {
* var min = keyValuePairs.Aggregate((l, r) => l.Value < r.Value ? l : r).Key;
* return min.body.gameObject;
* }*/
return(null);
}
public void OnKilledServer(DamageReport damageReport)
{
Vector3 position = Vector3.zero;
if (damageReport.attackerBody)
{
position = damageReport.victimBody.corePosition;
}
else
{
foreach (var teammate in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
if (teammate.body?.master?.playerCharacterMasterController)
{
position = teammate.body.corePosition;
}
}
}
DropItems(position);
PickupDropletController.CreatePickupDroplet(PickupCatalog.FindPickupIndex(equipmentIndex), position, Vector3.up * 20f);
DropCoins(position);
}
public override void OnEnter()
{
base.OnEnter();
if (base.teamComponent && NetworkServer.active)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(base.teamComponent.teamIndex);
Vector3 position = base.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
CharacterBody component = teamMembers[i].GetComponent <CharacterBody>();
if (component)
{
if (base.characterBody.skillLocator.utility.stock > 0 && !component.HasBuff(BuffIndex.EngiTeamShield))
{
component.AddTimedBuff(BuffIndex.EngiTeamShield, 8f);
component.AddTimedBuff(BuffIndex.TeslaField, 2f);
HealthComponent component2 = component.GetComponent <HealthComponent>();
if (component2)
{
component2.RechargeShieldFull();
}
base.skillLocator.utility.DeductStock(1);
}
}
}
}
}
private void ServerProc()
{
List <TeamComponent> teamMembers = new List <TeamComponent>();
bool isFF = FriendlyFireManager.friendlyFireMode != FriendlyFireManager.FriendlyFireMode.Off;
if (isFF || teamFilter.teamIndex != TeamIndex.Monster)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Monster));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Neutral)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Neutral));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Player)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Player));
}
float sqrad = radius * radius;
foreach (TeamComponent tcpt in teamMembers)
{
if ((tcpt.transform.position - transform.position).sqrMagnitude <= sqrad)
{
if (tcpt.body && tcpt.body.isActiveAndEnabled && tcpt.body.healthComponent && tcpt.body.mainHurtBox)
{
tcpt.body.AddTimedBuff(ClassicItemsPlugin.fearBuff, duration - lifeStopwatch);
tcpt.body.healthComponent?.TakeDamage(new DamageInfo {
attacker = owner,
crit = owner?.GetComponent <CharacterBody>()?.RollCrit() ?? false,
damage = this.damage * interval,
damageColorIndex = DamageColorIndex.Item,
damageType = DamageType.AOE,
force = Vector3.zero,
position = transform.position,
procChainMask = default,
private void FixedUpdate()
{
if (NetworkServer.active)
{
this.buffTimer -= Time.fixedDeltaTime;
if (this.buffTimer <= 0f)
{
this.buffTimer = this.interval;
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);
}
}
if (this.freezeProjectiles)
{
this.FreezeProjectiles(this.calculatedRadius * this.calculatedRadius, base.transform.position);
}
}
private static void DetonateAlive(float radius)
{
var currentBody = CameraRigController.readOnlyInstancesList.First().viewer.masterController.master.GetBody();
var stickyBomb = (GameObject)Resources.Load("Prefabs/Projectiles/StickyBomb");
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Monster);
foreach (var t in teamMembers)
{
float sqrDistance = Vector3.SqrMagnitude(t.transform.position - currentBody.transform.position);
if (sqrDistance <= (radius * radius))
{
Vector3 position = currentBody.transform.position;
Vector3 forward = t.transform.position - position;
Quaternion rotation = forward.magnitude != 0f
? Util.QuaternionSafeLookRotation(forward)
: Random.rotationUniform;
#pragma warning disable 618
ProjectileManager.instance.FireProjectile(stickyBomb,
#pragma warning restore 618
t.transform.position, rotation, currentBody.gameObject, currentBody.damage * 40, 100f,
Util.CheckRoll(currentBody.crit, currentBody.master), DamageColorIndex.Item, null,
forward.magnitude * 60f);
}
}
}
public void ApplyAmmoPackToTeam(TeamIndex teamIndex = TeamIndex.Player, bool restoreEquipmentCharges = true, bool restoreOffhandEquipmentCharges = true)
{
ReadOnlyCollection <TeamComponent> teamComponents = TeamComponent.GetTeamMembers(teamIndex);
foreach (TeamComponent teamComponent in teamComponents)
{
CharacterBody body = teamComponent.body;
if (body)
{
body.GetComponent <SkillLocator>()?.ApplyAmmoPack();
var inventory = body.inventory;
if (inventory)
{
if (restoreEquipmentCharges)
{
inventory.RestockEquipmentCharges(0, 1);
}
if (restoreOffhandEquipmentCharges)
{
for (int i = 0; i < inventory.GetEquipmentSlotCount() - 1; i++)
{
inventory.RestockEquipmentCharges((byte)Math.Min(i, 255), 1);
}
}
}
EffectManager.SimpleEffect(pickupEffect, body.transform.position, Quaternion.identity, true);
}
}
}
private void BuffTeam(TeamIndex teamIndex, BuffIndex[] buffIndices)
{
ReadOnlyCollection <TeamComponent> teamComponents = TeamComponent.GetTeamMembers(teamIndex);
foreach (var teamComponent in teamComponents)
{
CharacterBody body = teamComponent.body;
if (body)
{
if (body.bodyFlags.HasFlag(CharacterBody.BodyFlags.Mechanical))
{
body.AddTimedBuff(buildingDebuff, buffDuration);
var modelAnimator = Modules.Helpers.GetModelAnimator(body);
modelAnimator.bodyRotation = Util.QuaternionSafeLookRotation(Vector3.zero, Vector3.down);
modelAnimator.enabled = false;
}
else
{
foreach (BuffIndex buffIndex in buffIndices)
{
body.AddTimedBuff(buffIndex, buffDuration);
}
}
}
}
}
// Token: 0x0600310D RID: 12557 RVA: 0x000D300C File Offset: 0x000D120C
public override void OnEnter()
{
base.OnEnter();
if (base.teamComponent && NetworkServer.active)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(base.teamComponent.teamIndex);
float num = EngiTeamShield.radius * EngiTeamShield.radius;
Vector3 position = base.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
if ((teamMembers[i].transform.position - position).sqrMagnitude <= num)
{
CharacterBody component = teamMembers[i].GetComponent <CharacterBody>();
if (component)
{
component.AddTimedBuff(BuffIndex.EngiTeamShield, EngiTeamShield.duration);
HealthComponent component2 = component.GetComponent <HealthComponent>();
if (component2)
{
component2.RechargeShieldFull();
}
}
}
}
}
}
public override void OnEnter()
{
base.OnEnter();
this.duration = this.baseDuration / Mathf.Sqrt(base.attackSpeedStat);
this.explosionInterval = this.duration / Sacrifice.explosionCount;
this.explosionIndex = 0;
weakStans = new List <CharacterBody>();
strongStans = new List <CharacterBody>();
foreach (TeamComponent i in TeamComponent.GetTeamMembers(this.GetTeam()))
{
if (i.gameObject && i.body.master.minionOwnership.ownerMaster == this.characterBody.master && i.body.master.bodyPrefab)
{
if (i.body.master.bodyPrefab == Survivor.Summons.weakStanFragmentBody)
{
weakStans.Add(i.body);
}
else if (i.body.master.bodyPrefab == Survivor.Summons.strongStanFragmentBody)
{
strongStans.Add(i.body);
}
}
}
this.ApplyNetworkedTimedBuff(base.gameObject, Survivor.Buffs.sacrificeBuff, 1, Sacrifice.buffDuration);
}
private void UpdateGurrenPassive()
{
checkGurrenPassiveStopWatch += Time.fixedDeltaTime;
if (checkGurrenPassiveStopWatch > checkGurrenPassiveInterval)
{
checkGurrenPassiveStopWatch = 0f;
if (this.body)
{
int buffCounts = 0;
var gurrenBodyIndex = BodyCatalog.FindBodyIndex("GurrenBody");
var allies = TeamComponent.GetTeamMembers(TeamIndex.Player);
foreach (var ally in allies)
{
var allyBody = ally.body;
if (allyBody && allyBody != this.body &&
allyBody.bodyIndex == gurrenBodyIndex &&
(Vector3.Distance(allyBody.transform.position, this.body.transform.position) <= Components.GurrenController.passiveDistance))
{
buffCounts++;
}
}
this.body.SetBuffCount(Buffs.kaminaBuff.buffIndex, buffCounts);
}
}
}
// Token: 0x06002D1F RID: 11551 RVA: 0x000BE8A5 File Offset: 0x000BCAA5
private void FixedUpdateServer()
{
if (TeamComponent.GetTeamMembers(TeamIndex.Monster).Count == 0)
{
this.outer.SetNextState(new FadeOut());
}
}
public override void OnEnter()
{
base.OnEnter();
if (NetworkServer.active)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(base.teamComponent.teamIndex);
Vector3 position = base.transform.position;
for (int i = 0; i < teamMembers.Count; i++)
{
CharacterBody component = teamMembers[i].GetComponent <CharacterBody>();
if (component)
{
if (base.characterBody.skillLocator.utility.stock > 0 && !component.HasBuff(BuffIndex.EngiShield) && !component.HasBuff(BuffIndex.ElephantArmorBoost))
{
component.AddTimedBuff(BuffIndex.EngiShield, 3f);
component.AddTimedBuff(BuffIndex.Immune, 3f);
component.AddTimedBuff(BuffIndex.ElephantArmorBoost, 6f);
HealthComponent component2 = component.GetComponent <HealthComponent>();
if (component2)
{
component2.RechargeShieldFull();
}
base.skillLocator.utility.DeductStock(1);
}
}
}
}
base.OnExit();
base.outer.SetNextStateToMain();
}
public void RunOnTeleporterBeginChargingGlobal(TeleporterInteraction teleporterInteraction)
{
if (NetworkServer.active)
{
foreach (var teamComponent in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
CharacterBody body = teamComponent.body;
if (body)
{
CharacterMaster master = teamComponent.body.master;
if (master)
{
int itemCount = master.inventory.GetItemCount(RoR2Content.Items.WardOnLevel);
if (itemCount > 0)
{
GameObject gameObject = Object.Instantiate <GameObject>(LegacyResourcesAPI.Load <GameObject>("Prefabs/NetworkedObjects/WarbannerWard"), body.transform.position, Quaternion.identity);
gameObject.GetComponent <TeamFilter>().teamIndex = TeamIndex.Player;
gameObject.GetComponent <BuffWard>().Networkradius = 8f + 8f * (float)itemCount;
NetworkServer.Spawn(gameObject);
}
}
}
}
}
}
public void LoadData()
{
var newRun = Run.instance;
TeamManager.instance.SetTeamLevel(TeamIndex.Player, 0);
TeamManager.instance.GiveTeamExperience(TeamIndex.Player, (ulong)teamExp);
TeamManager.instance.SetTeamLevel(TeamIndex.Monster, 1);
newRun.seed = ulong.Parse(seed);
newRun.selectedDifficulty = (DifficultyIndex)difficulty;
newRun.fixedTime = fixedTime;
var stopwatch = newRun.GetFieldValue <Run.RunStopwatch>("runStopwatch");
stopwatch.offsetFromFixedTime = 0f;
stopwatch.isPaused = false;
newRun.SetFieldValue("runStopwatch", stopwatch);
newRun.runRNG = new Xoroshiro128Plus(ulong.Parse(seed));
newRun.nextStageRng = new Xoroshiro128Plus(newRun.runRNG.nextUlong);
newRun.stageRngGenerator = new Xoroshiro128Plus(newRun.runRNG.nextUlong);
int dummy;
for (int i = 0; i < stageClearCount; i++)
{
dummy = (int)newRun.stageRngGenerator.nextUlong;
dummy = newRun.nextStageRng.RangeInt(0, 1);
dummy = newRun.nextStageRng.RangeInt(0, 1);
}
//Clearing drones to avoid them carrying over to the new loaded run
foreach (var item in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
var body = item.GetComponent <CharacterBody>();
if (body)
{
if (!body.isPlayerControlled)
{
item.GetComponent <HealthComponent>()?.Suicide();
}
}
}
// Doesn't work anymore the sceneDef doesn't specify the map variant and a random one is chosen
//newRun.AdvanceStage(SceneCatalog.GetSceneDefFromSceneName(sceneName));
if (Stage.instance)
{
Stage.instance.CompleteServer();
}
newRun.InvokeMethod("GenerateStageRNG");
NetworkManager.singleton.ServerChangeScene(sceneName);
newRun.stageClearCount = stageClearCount;
}
private void On_ESDetonate(On.EntityStates.Engi.Mine.Detonate.orig_Explode orig, Detonate self)
{
if (self.outer.name != "FootMine(Clone)")
{
orig(self);
}
else if (NetworkServer.active)
{
List <TeamComponent> teamMembers = new List <TeamComponent>();
TeamFilter teamFilter = self.GetComponent <TeamFilter>();
float blastRadius = Detonate.blastRadius * 1.2f;
float sqrad = blastRadius * blastRadius;
bool isFF = FriendlyFireManager.friendlyFireMode != FriendlyFireManager.FriendlyFireMode.Off;
GameObject owner = self.projectileController.owner;
int icnt = (int)self.GetComponent <ProjectileDamage>().damage; // this is actually the stack number
if (isFF || teamFilter.teamIndex != TeamIndex.Monster)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Monster));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Neutral)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Neutral));
}
if (isFF || teamFilter.teamIndex != TeamIndex.Player)
{
teamMembers.AddRange(TeamComponent.GetTeamMembers(TeamIndex.Player));
}
if (owner)
{
teamMembers.Remove(owner.GetComponent <TeamComponent>());
}
foreach (TeamComponent tcpt in teamMembers)
{
if ((tcpt.transform.position - self.transform.position).sqrMagnitude <= sqrad)
{
if (tcpt.body && tcpt.body.mainHurtBox && tcpt.body.isActiveAndEnabled)
{
DotController.InflictDot(tcpt.gameObject, owner, poisonDot, baseTicks + stackTicks * (icnt - 1), baseDmg + stackDmg * (icnt - 1));
}
}
}
if (Detonate.explosionEffectPrefab)
{
EffectManager.SpawnEffect(Detonate.explosionEffectPrefab, new EffectData
{
origin = self.transform.position,
rotation = self.transform.rotation,
scale = blastRadius
}, true);
}
EntityState.Destroy(self.gameObject);
}
}
private void TrueSuicideOnNullVoid(On.RoR2.ArenaMissionController.orig_EndRound orig, ArenaMissionController self)
{
if (self.currentRound >= self.totalRoundsMax)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Monster);
for (int j = teamMembers.Count - 1; j >= 0; j--)
{
teamMembers[j].body.inventory.ResetItem(ItemIndex.ExtraLife);
}
}
orig(self);
}
private void SearchListForMinion()
{
if (this.owner)
{
var players = TeamComponent.GetTeamMembers(TeamIndex.Player);
foreach (var player in players)
{
if (player.body && player.body.master)
{
AssignMinion(player.body.master);
}
}
}
}
protected override bool PerformEquipmentAction(EquipmentSlot slot)
{
if (!slot.characterBody || !slot.characterBody.teamComponent)
{
return(false);
}
var tpos = slot.characterBody.transform.position;
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers((TeamIndex.Player | TeamIndex.Neutral | TeamIndex.Monster) & ~slot.characterBody.teamComponent.teamIndex);
float lowestDist = float.MaxValue;
HurtBox result = null;
float secondLowestDist = float.MaxValue;
HurtBox result2 = null;
foreach (TeamComponent tcpt in teamMembers)
{
if (!tcpt.body || !tcpt.body.isActiveAndEnabled || !tcpt.body.mainHurtBox)
{
continue;
}
float currDist = Vector3.SqrMagnitude(tcpt.transform.position - tpos);
if (currDist < lowestDist)
{
secondLowestDist = lowestDist;
result2 = result;
lowestDist = currDist;
result = tcpt.body.mainHurtBox;
}
if (currDist < secondLowestDist && currDist > lowestDist)
{
secondLowestDist = currDist;
result2 = tcpt.body.mainHurtBox;
}
}
var myHcpt = slot.characterBody?.healthComponent ?? null;
bool didHit = false;
if (myHcpt)
{
if (result)
{
OrbManager.instance.AddOrb(new LostDollOrb {
attacker = slot.characterBody.gameObject,
damageColorIndex = DamageColorIndex.Default,
damageValue = myHcpt.fullCombinedHealth * damageGiven,
isCrit = false,
origin = slot.characterBody.corePosition,
target = result,
procCoefficient = 0f,
procChainMask = default,
private void FixedUpdate()
{
if (NetworkServer.active)
{
stopwatch -= Time.fixedDeltaTime;
if (stopwatch <= 0f)
{
stopwatch = interval;
float radiusSqr = calculatedRadius * calculatedRadius;
Vector3 position = transform.position;
GenerateAggro(TeamComponent.GetTeamMembers(TeamIndex.Monster), radiusSqr, position);
}
}
}
public void LoadData()
{
var newRun = Run.instance;
TeamManager.instance.SetTeamLevel(TeamIndex.Player, 0);
TeamManager.instance.GiveTeamExperience(TeamIndex.Player, (ulong)teamExp);
TeamManager.instance.SetTeamLevel(TeamIndex.Monster, 1);
newRun.seed = ulong.Parse(seed);
newRun.selectedDifficulty = (DifficultyIndex)difficulty;
newRun.fixedTime = fixedTime;
var stopwatch = newRun.GetFieldValue <Run.RunStopwatch>("runStopwatch");
stopwatch.offsetFromFixedTime = 0f;
stopwatch.isPaused = false;
newRun.SetFieldValue("runStopwatch", stopwatch);
newRun.runRNG = new Xoroshiro128Plus(ulong.Parse(seed));
newRun.nextStageRng = new Xoroshiro128Plus(newRun.runRNG.nextUlong);
newRun.stageRngGenerator = new Xoroshiro128Plus(newRun.runRNG.nextUlong);
int dummy;
for (int i = 0; i < stageClearCount; i++)
{
dummy = (int)newRun.stageRngGenerator.nextUlong;
dummy = newRun.nextStageRng.RangeInt(0, 1);
dummy = newRun.nextStageRng.RangeInt(0, 1);
}
//Clearing drones to avoid them carrying over to the new loaded run
foreach (var item in TeamComponent.GetTeamMembers(TeamIndex.Player))
{
var body = item.GetComponent <CharacterBody>();
if (body)
{
if (!body.isPlayerControlled)
{
item.GetComponent <HealthComponent>()?.Suicide();
}
}
}
newRun.AdvanceStage(sceneName);
newRun.stageClearCount = stageClearCount;
}
private void GlobalEventManager_onCharacterDeathGlobal(DamageReport damageReport)
{
if (damageReport.victimBodyIndex != requiredBodyIndex)
{
return;
}
foreach (var teamMember in TeamComponent.GetTeamMembers(serverAchievementTracker.networkUser.master.teamIndex))
{
if (teamMember.body != serverAchievementTracker.networkUser.GetCurrentBody() && teamMember.body.healthComponent && teamMember.body.healthComponent.alive)
{
return;
}
}
Grant();
}
private int GetPlayerCountInRadius()
{
int num = 0;
Vector3 position = transform.position;
float num2 = clearRadius * clearRadius;
var teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Player);
for (int i = 0; i < teamMembers.Count; i++)
{
if (Util.LookUpBodyNetworkUser(teamMembers[i].gameObject) && (teamMembers[i].transform.position - position).sqrMagnitude <= num2)
{
num++;
}
}
return(num);
}
// Token: 0x06001DE4 RID: 7652 RVA: 0x0008C8CC File Offset: 0x0008AACC
private Transform FindTarget()
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Monster);
float num = 99999f;
Transform result = null;
for (int i = 0; i < teamMembers.Count; i++)
{
float num2 = Vector3.SqrMagnitude(teamMembers[i].transform.position - this.transform.position);
if (num2 < num)
{
num = num2;
result = teamMembers[i].transform;
}
}
return(result);
}
// Token: 0x06002C9B RID: 11419 RVA: 0x000BC2A0 File Offset: 0x000BA4A0
private Transform FindTargetClosest(Vector3 point, TeamIndex enemyTeam)
{
ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(enemyTeam);
float num = 99999f;
Transform result = null;
for (int i = 0; i < teamMembers.Count; i++)
{
float num2 = Vector3.SqrMagnitude(teamMembers[i].transform.position - point);
if (num2 < num)
{
num = num2;
result = teamMembers[i].transform;
}
}
return(result);
}
