private void StopRolling(bool bounceBack)
{
if (bounceBack && !m_isBouncingBack)
{
StartCoroutine(HandleBounceback());
}
else
{
spriteAnimator.Stop();
if (hasRollingAnimations)
{
if (IsRollAnimation())
{
tk2dSpriteAnimationClip currentClip = spriteAnimator.CurrentClip;
spriteAnimator.Stop();
spriteAnimator.Sprite.SetSprite(currentClip.frames[currentClip.frames.Length - 1].spriteId);
}
}
base.specRigidbody.Velocity = Vector2.zero;
MinorBreakable component = GetComponent <MinorBreakable>();
if (component != null)
{
component.onlyVulnerableToGunfire = false;
}
SpeculativeRigidbody specRigidbody = base.specRigidbody;
specRigidbody.OnCollision = (Action <CollisionData>)Delegate.Remove(specRigidbody.OnCollision, new Action <CollisionData>(OnCollision));
SpeculativeRigidbody specRigidbody2 = base.specRigidbody;
specRigidbody2.MovementRestrictor = (SpeculativeRigidbody.MovementRestrictorDelegate)Delegate.Remove(specRigidbody2.MovementRestrictor, new SpeculativeRigidbody.MovementRestrictorDelegate(NoPits));
RoomHandler.unassignedInteractableObjects.Add(this);
m_isBouncingBack = false;
}
}
public static void DoRadialMinorBreakableBreak(Vector3 position, float radius)
{
float num = radius * radius;
List <MinorBreakable> allMinorBreakables = StaticReferenceManager.AllMinorBreakables;
if (allMinorBreakables != null)
{
for (int i = 0; i < allMinorBreakables.Count; i++)
{
MinorBreakable minorBreakable = allMinorBreakables[i];
if (minorBreakable)
{
if (!minorBreakable.resistsExplosions)
{
if (!minorBreakable.OnlyBrokenByCode)
{
Vector2 vector = minorBreakable.CenterPoint - position.XY();
if (vector.sqrMagnitude < num)
{
minorBreakable.Break(vector.normalized);
}
}
}
}
}
}
}
private IEnumerator BreakBarrel(MinorBreakable breakable)
{
yield return(new WaitForSeconds(15f));
breakable.Break();
yield break;
}
private IEnumerator HandlePotSuck(MinorBreakable target)
{
Transform copySprite = this.CreatePotSprite(target);
Vector3 startPosition = copySprite.transform.position;
float elapsed = 0f;
float duration = 0.5f;
while (elapsed < duration)
{
elapsed += BraveTime.DeltaTime;
if (this.m_owner.CurrentGun && copySprite)
{
Vector3 position = this.m_owner.CurrentGun.PrimaryHandAttachPoint.position;
float t = elapsed / duration * (elapsed / duration);
copySprite.position = Vector3.Lerp(startPosition, position, t);
copySprite.rotation = Quaternion.Euler(0f, 0f, 360f * BraveTime.DeltaTime) * copySprite.rotation;
copySprite.localScale = Vector3.Lerp(Vector3.one, new Vector3(0.1f, 0.1f, 0.1f), t);
}
yield return(null);
}
if (copySprite)
{
UnityEngine.Object.Destroy(copySprite.gameObject);
}
if (this.m_owner.CurrentGun)
{
this.m_owner.CurrentGun.GainAmmo(1);
}
yield break;
}
public void Update()
{
if (m_WasKicked)
{
if (GetAbsoluteParentRoom() == null)
{
m_WasKicked = false;
willDefinitelyExplode = true;
SelfDestructOnKick();
}
FlippableCover m_Table = GetComponent <FlippableCover>();
if (m_Table)
{
if (m_Table.IsBroken)
{
m_WasKicked = false;
willDefinitelyExplode = true;
SelfDestructOnKick();
}
}
}
if (m_shouldDisplayOutline)
{
int num;
DungeonData.Direction inverseDirection = DungeonData.GetInverseDirection(DungeonData.GetDirectionFromIntVector2(GetFlipDirection(m_lastInteractingPlayer.specRigidbody, out num)));
if (inverseDirection != m_lastOutlineDirection || sprite.spriteId != m_lastSpriteId)
{
SpriteOutlineManager.RemoveOutlineFromSprite(sprite, false);
SpriteOutlineManager.AddSingleOutlineToSprite <tk2dSprite>(sprite, DungeonData.GetIntVector2FromDirection(inverseDirection), Color.white, 0.25f, 0f);
}
m_lastOutlineDirection = inverseDirection;
m_lastSpriteId = sprite.spriteId;
}
if (leavesGoopTrail && specRigidbody.Velocity.magnitude > 0.1f)
{
m_goopElapsed += BraveTime.DeltaTime;
if (m_goopElapsed > goopFrequency)
{
m_goopElapsed -= BraveTime.DeltaTime;
if (m_goopManager == null)
{
m_goopManager = DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(goopType);
}
m_goopManager.AddGoopCircle(sprite.WorldCenter, goopRadius + 0.1f, -1, false, -1);
}
if (AllowTopWallTraversal && GameManager.Instance.Dungeon.data.CheckInBoundsAndValid(sprite.WorldCenter.ToIntVector2(VectorConversions.Floor)) && GameManager.Instance.Dungeon.data[sprite.WorldCenter.ToIntVector2(VectorConversions.Floor)].IsFireplaceCell)
{
MinorBreakable component = GetComponent <MinorBreakable>();
if (component && !component.IsBroken)
{
component.Break(Vector2.zero);
GameStatsManager.Instance.SetFlag(GungeonFlags.FLAG_ROLLED_BARREL_INTO_FIREPLACE, true);
}
}
}
}
private IEnumerator HandleShatter(PlayerController interactor, bool skipInitialWait = false)
{
if (!skipInitialWait)
{
yield return(new WaitForSeconds(0.5f));
}
if (this)
{
AkSoundEngine.PostEvent("Play_OBJ_crystal_shatter_01", gameObject);
AkSoundEngine.PostEvent("Play_OBJ_pot_shatter_01", gameObject);
AkSoundEngine.PostEvent("Play_OBJ_glass_shatter_01", gameObject);
}
StatModifier curse = new StatModifier();
curse.statToBoost = PlayerStats.StatType.Curse;
curse.amount = CURSE_EXPOSED;
curse.modifyType = StatModifier.ModifyMethod.ADDITIVE;
if (!interactor)
{
interactor = GameManager.Instance.PrimaryPlayer;
}
if (interactor)
{
interactor.ownerlessStatModifiers.Add(curse);
interactor.stats.RecalculateStats(interactor, false, false);
}
MinorBreakable childBreakable = GetComponentInChildren <MinorBreakable>();
if (childBreakable)
{
childBreakable.Break();
while (childBreakable)
{
yield return(null);
}
}
tk2dSpriteAnimator eyeBall = GetComponentInChildren <tk2dSpriteAnimator>();
if (eyeBall)
{
eyeBall.Play("haunted_mirror_eye");
}
if (ShatterSystem)
{
ShatterSystem.SetActive(true);
}
yield return(new WaitForSeconds(2.5f));
if (ShatterSystem)
{
ShatterSystem.GetComponent <ParticleSystem>().Pause(false);
}
yield break;
}
private void EnterRoom()
{
RoomHandler currentRoom = GameManager.Instance.PrimaryPlayer.CurrentRoom;
for (int i = 0; i < StaticReferenceManager.AllMinorBreakables.Count; i++)
{
MinorBreakable minorBreakable = StaticReferenceManager.AllMinorBreakables[i];
if (minorBreakable && !minorBreakable.IsBroken && minorBreakable.CenterPoint.GetAbsoluteRoom() == currentRoom && !minorBreakable.IgnoredForPotShotsModifier)
{
MinorBreakable minorBreakable2 = minorBreakable;
minorBreakable2.OnBreakContext = (Action <MinorBreakable>)Delegate.Combine(minorBreakable2.OnBreakContext, new Action <MinorBreakable>(this.HandleBroken));
}
}
}
private void OnPreCollision(SpeculativeRigidbody myRigidbody, PixelCollider myPixelCollider, SpeculativeRigidbody otherRigidbody, PixelCollider otherPixelCollider)
{
MinorBreakable component = otherRigidbody.GetComponent <MinorBreakable>();
if (component && !component.onlyVulnerableToGunfire && !component.IsBig)
{
component.Break(specRigidbody.Velocity);
PhysicsEngine.SkipCollision = true;
}
if (otherRigidbody && otherRigidbody.aiActor && !otherRigidbody.aiActor.IsNormalEnemy)
{
PhysicsEngine.SkipCollision = true;
}
}
private Transform CreatePotSprite(MinorBreakable target)
{
GameObject gameObject = new GameObject("suck image");
gameObject.layer = target.gameObject.layer;
tk2dSprite tk2dSprite = gameObject.AddComponent <tk2dSprite>();
gameObject.transform.parent = SpawnManager.Instance.VFX;
tk2dSprite.SetSprite(target.sprite.Collection, target.sprite.spriteId);
tk2dSprite.transform.position = target.sprite.transform.position;
GameObject gameObject2 = new GameObject("image parent");
gameObject2.transform.position = tk2dSprite.WorldCenter;
tk2dSprite.transform.parent = gameObject2.transform;
return(gameObject2.transform);
}
private void OnPlayerCollision(CollisionData rigidbodyCollision)
{
PlayerController component = rigidbodyCollision.OtherRigidbody.GetComponent <PlayerController>();
if (RollingDestroysSafely && component != null && component.IsDodgeRolling)
{
MinorBreakable component2 = GetComponent <MinorBreakable>();
component2.destroyOnBreak = true;
component2.makeParallelOnBreak = false;
if (hasRollingAnimations)
{
component2.breakAnimName = RollingBreakAnim;
}
component2.explodesOnBreak = false;
component2.Break(-rigidbodyCollision.Normal);
}
}
private void SuckPots()
{
List <MinorBreakable> allMinorBreakables = StaticReferenceManager.AllMinorBreakables;
for (int k = allMinorBreakables.Count - 1; k >= 0; k--)
{
MinorBreakable minorBreakable = allMinorBreakables[k];
if (minorBreakable && minorBreakable.specRigidbody)
{
if (!minorBreakable.IsBroken && minorBreakable.sprite)
{
Vector2 vector = minorBreakable.sprite.WorldCenter - this.m_owner.sprite.WorldCenter;
bool flag = (vector.sqrMagnitude < (6 * 6));
if (flag)
{
GameManager.Instance.Dungeon.StartCoroutine(this.HandlePotSuck(minorBreakable));
minorBreakable.Break();
}
}
}
}
}
protected SpeculativeRigidbody IterativeRaycast(Vector2 rayOrigin, Vector2 rayDirection, float rayDistance, int collisionMask, SpeculativeRigidbody ignoreRigidbody)
{
int num = 0;
RaycastResult raycastResult;
while (PhysicsEngine.Instance.Raycast(rayOrigin, rayDirection, rayDistance, out raycastResult, true, true, collisionMask, new CollisionLayer?(CollisionLayer.Projectile), false, null, ignoreRigidbody))
{
num++;
SpeculativeRigidbody speculativeRigidbody = raycastResult.SpeculativeRigidbody;
if (num < 3 && speculativeRigidbody != null)
{
MinorBreakable component = speculativeRigidbody.GetComponent <MinorBreakable>();
if (component != null)
{
component.Break(rayDirection.normalized * 3f);
RaycastResult.Pool.Free(ref raycastResult);
continue;
}
}
RaycastResult.Pool.Free(ref raycastResult);
return(speculativeRigidbody);
}
return(null);
}
private void Kick(SpeculativeRigidbody kickerRigidbody)
{
m_WasKicked = true;
if (explodesOnKick)
{
try {
if (willDefinitelyExplode)
{
Invoke("SelfDestructOnKick", UnityEngine.Random.Range(0f, 0.15f));
}
else
{
Invoke("SelfDestructOnKick", UnityEngine.Random.Range(0.25f, 3f));
}
} catch (Exception ex) {
if (ExpandSettings.debugMode)
{
ETGModConsole.Log("Exception Caught at [SelfDestructOnKick] in ExpandKickableObject class.", false);
ETGModConsole.Log(ex.Message + ex.Source + ex.StackTrace, false);
}
}
}
try {
if (base.specRigidbody && !base.specRigidbody.enabled)
{
return;
}
RemoveFromRoomHierarchy();
List <SpeculativeRigidbody> overlappingRigidbodies = PhysicsEngine.Instance.GetOverlappingRigidbodies(base.specRigidbody.PrimaryPixelCollider, null, false);
for (int i = 0; i < overlappingRigidbodies.Count; i++)
{
if (overlappingRigidbodies[i] && overlappingRigidbodies[i].minorBreakable && !overlappingRigidbodies[i].minorBreakable.IsBroken && !overlappingRigidbodies[i].minorBreakable.onlyVulnerableToGunfire && !overlappingRigidbodies[i].minorBreakable.OnlyBrokenByCode)
{
overlappingRigidbodies[i].minorBreakable.Break();
}
}
int value = ~CollisionMask.LayerToMask(CollisionLayer.PlayerCollider, CollisionLayer.PlayerHitBox);
PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(base.specRigidbody, new int?(value), false);
SpeculativeRigidbody specRigidbody = base.specRigidbody;
if (specRigidbody != null && specRigidbody.MovementRestrictor != null)
{
specRigidbody.MovementRestrictor = (SpeculativeRigidbody.MovementRestrictorDelegate)Delegate.Combine(specRigidbody.MovementRestrictor, new SpeculativeRigidbody.MovementRestrictorDelegate(NoPits));
SpeculativeRigidbody specRigidbody2 = base.specRigidbody;
specRigidbody2.OnCollision = (Action <CollisionData>)Delegate.Combine(specRigidbody2.OnCollision, new Action <CollisionData>(OnCollision));
SpeculativeRigidbody specRigidbody3 = base.specRigidbody;
specRigidbody3.OnPreRigidbodyCollision = (SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate)Delegate.Combine(specRigidbody3.OnPreRigidbodyCollision, new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(OnPreCollision));
}
else if (specRigidbody != null)
{
specRigidbody.MovementRestrictor = new SpeculativeRigidbody.MovementRestrictorDelegate(NoPits);
SpeculativeRigidbody specRigidbody2 = base.specRigidbody;
specRigidbody2.OnCollision = (Action <CollisionData>)Delegate.Combine(specRigidbody2.OnCollision, new Action <CollisionData>(OnCollision));
SpeculativeRigidbody specRigidbody3 = base.specRigidbody;
specRigidbody3.OnPreRigidbodyCollision = (SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate)Delegate.Combine(specRigidbody3.OnPreRigidbodyCollision, new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(OnPreCollision));
}
int num;
IntVector2 flipDirection = GetFlipDirection(kickerRigidbody, out num);
if (AllowTopWallTraversal)
{
base.specRigidbody.AddCollisionLayerOverride(CollisionMask.LayerToMask(CollisionLayer.EnemyBlocker));
}
base.specRigidbody.Velocity = rollSpeed * flipDirection.ToVector2();
tk2dSpriteAnimationClip clipByName = null;
if (hasRollingAnimations)
{
clipByName = spriteAnimator.GetClipByName(rollAnimations[num]);
}
bool flag = false;
if (m_lastDirectionKicked != null)
{
if (m_lastDirectionKicked.Value.y == 0 && flipDirection.y == 0)
{
flag = true;
}
if (m_lastDirectionKicked.Value.x == 0 && flipDirection.x == 0)
{
flag = true;
}
}
if (hasRollingAnimations)
{
if (clipByName != null && clipByName.wrapMode == tk2dSpriteAnimationClip.WrapMode.LoopSection && flag)
{
spriteAnimator.PlayFromFrame(clipByName, clipByName.loopStart);
}
else
{
spriteAnimator.Play(clipByName);
}
}
if (triggersBreakTimer && !m_timerIsActive)
{
StartCoroutine(HandleBreakTimer());
}
MinorBreakable component = GetComponent <MinorBreakable>();
if (component != null)
{
if (impactAnimations[num] != null)
{
component.breakAnimName = impactAnimations[num];
}
component.onlyVulnerableToGunfire = true;
}
IntVector2 key = transform.PositionVector2().ToIntVector2(VectorConversions.Round);
GameManager.Instance.Dungeon.data[key].isOccupied = false;
m_lastDirectionKicked = new IntVector2?(flipDirection);
} catch (Exception) {
if (ExpandSettings.debugMode)
{
ETGModConsole.Log("Exception Caught at [Kick] in ExpandKickableObject class.", false);
}
return;
}
}
private IEnumerator HandleExplosion(Vector3 position, ExplosionData data, Vector2 sourceNormal, Action onExplosionBegin, bool ignoreQueues, CoreDamageTypes damageTypes, bool ignoreDamageCaps)
{
if (data.usesComprehensiveDelay)
{
yield return(new WaitForSeconds(data.comprehensiveDelay));
}
Exploder.OnExplosionTriggered?.Invoke();
bool addFireGoop = (damageTypes | CoreDamageTypes.Fire) == damageTypes;
bool addFreezeGoop = (damageTypes | CoreDamageTypes.Ice) == damageTypes;
bool addPoisonGoop = (damageTypes | CoreDamageTypes.Poison) == damageTypes;
bool isFreezeExplosion = data.isFreezeExplosion;
if (!data.isFreezeExplosion && addFreezeGoop)
{
isFreezeExplosion = true;
data.freezeRadius = data.damageRadius;
data.freezeEffect = GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFreezeExplosionEffect;
}
// Be sure to use a clone of ExplosionManager for this else explosion queueing breaks! //
// (it won't let you use ExplosionManager's original code on a new Exploder class normally. ;) - [Apache Thunder] //
if (!ignoreQueues)
{
ChaosExplosionManager.Instance.Queue(this);
while (!ChaosExplosionManager.Instance.IsExploderReady(this))
{
yield return(null);
}
ChaosExplosionManager.Instance.Dequeue();
if (ChaosExplosionManager.Instance.QueueCount == 0)
{
ChaosExplosionManager.Instance.StartCoroutine(HandleCurrentExplosionNotification(0.5f));
}
}
onExplosionBegin?.Invoke();
float damageRadius = data.GetDefinedDamageRadius();
float pushSqrRadius = data.pushRadius * data.pushRadius;
float bulletDeletionSqrRadius = damageRadius * damageRadius;
if (addFreezeGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFreezeGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
DeadlyDeadlyGoopManager.FreezeGoopsCircle(position.XY(), damageRadius);
}
if (addFireGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultFireGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
}
if (addPoisonGoop)
{
DeadlyDeadlyGoopManager.GetGoopManagerForGoopType(GameManager.Instance.Dungeon.sharedSettingsPrefab.DefaultPoisonGoop).TimedAddGoopCircle(position.XY(), damageRadius, 0.5f, false);
}
if (!isFreezeExplosion)
{
DeadlyDeadlyGoopManager.IgniteGoopsCircle(position.XY(), damageRadius);
}
if (data.effect)
{
GameObject gameObject;
if (data.effect.GetComponent <ParticleSystem>() != null || data.effect.GetComponentInChildren <ParticleSystem>() != null)
{
gameObject = SpawnManager.SpawnVFX(data.effect, position, Quaternion.identity);
}
else
{
gameObject = SpawnManager.SpawnVFX(data.effect, position, Quaternion.identity);
}
if (data.rotateEffectToNormal && gameObject)
{
gameObject.transform.rotation = Quaternion.Euler(0f, 0f, sourceNormal.ToAngle());
}
tk2dBaseSprite component = gameObject.GetComponent <tk2dBaseSprite>();
if (component)
{
component.HeightOffGround += UnityEngine.Random.Range(-0.1f, 0.2f);
component.UpdateZDepth();
}
ExplosionDebrisLauncher[] componentsInChildren = gameObject.GetComponentsInChildren <ExplosionDebrisLauncher>();
Vector3 position2 = gameObject.transform.position.WithZ(gameObject.transform.position.y);
GameObject gameObject2 = new GameObject("SoundSource");
gameObject2.transform.position = position2;
if (data.playDefaultSFX)
{
AkSoundEngine.PostEvent("Play_WPN_grenade_blast_01", gameObject2);
}
Destroy(gameObject2, 5f);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (componentsInChildren[i])
{
if (sourceNormal == Vector2.zero)
{
componentsInChildren[i].Launch();
}
else
{
componentsInChildren[i].Launch(sourceNormal);
}
}
}
if (gameObject)
{
Transform transform = gameObject.transform.Find("scorch");
if (transform)
{
transform.gameObject.SetLayerRecursively(LayerMask.NameToLayer("BG_Critical"));
}
}
if (data.doExplosionRing)
{
}
}
yield return(new WaitForSeconds(data.explosionDelay));
List <HealthHaver> allHealth = StaticReferenceManager.AllHealthHavers;
if (allHealth != null && (data.doDamage || data.doForce))
{
for (int j = 0; j < allHealth.Count; j++)
{
HealthHaver healthHaver = allHealth[j];
if (healthHaver)
{
if (healthHaver && healthHaver.aiActor)
{
if (!healthHaver.aiActor.HasBeenEngaged)
{
goto IL_A82;
}
if (healthHaver.aiActor.CompanionOwner && data.damageToPlayer == 0f)
{
goto IL_A82;
}
}
if (!data.ignoreList.Contains(healthHaver.specRigidbody))
{
if (position.GetAbsoluteRoom() == allHealth[j].transform.position.GetAbsoluteRoom())
{
for (int k = 0; k < healthHaver.NumBodyRigidbodies; k++)
{
SpeculativeRigidbody bodyRigidbody = healthHaver.GetBodyRigidbody(k);
PlayerController playerController = (!bodyRigidbody) ? null : (bodyRigidbody.gameActor as PlayerController);
Vector2 a = healthHaver.transform.position.XY();
Vector2 vector = a - position.XY();
bool flag = false;
float num;
if (bodyRigidbody.HitboxPixelCollider != null)
{
a = bodyRigidbody.HitboxPixelCollider.UnitCenter;
vector = a - position.XY();
num = BraveMathCollege.DistToRectangle(position.XY(), bodyRigidbody.HitboxPixelCollider.UnitBottomLeft, bodyRigidbody.HitboxPixelCollider.UnitDimensions);
}
else
{
a = healthHaver.transform.position.XY();
vector = a - position.XY();
num = vector.magnitude;
}
if (!playerController || ((!data.doDamage || num >= damageRadius) && (!isFreezeExplosion || num >= data.freezeRadius) && (!data.doForce || num >= data.pushRadius)) || !IsPlayerBlockedByWall(playerController, position))
{
if (playerController)
{
if (!bodyRigidbody.CollideWithOthers)
{
goto IL_A6E;
}
if (playerController.DodgeRollIsBlink && playerController.IsDodgeRolling)
{
goto IL_A6E;
}
}
if (data.doDamage && num < damageRadius)
{
if (playerController)
{
bool flag2 = true;
if (PassiveItem.ActiveFlagItems.ContainsKey(playerController) && PassiveItem.ActiveFlagItems[playerController].ContainsKey(typeof(HelmetItem)) && num > damageRadius * HelmetItem.EXPLOSION_RADIUS_MULTIPLIER)
{
flag2 = false;
}
if (flag2 && !playerController.IsEthereal)
{
HealthHaver healthHaver2 = healthHaver;
float damage = data.damageToPlayer;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes2 = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver2.ApplyDamage(damage, direction, enemiesString, damageTypes2, damageCategory, false, null, ignoreDamageCaps);
}
}
else
{
HealthHaver healthHaver3 = healthHaver;
float damage = data.damage;
Vector2 direction = vector;
string enemiesString = StringTableManager.GetEnemiesString("#EXPLOSION", -1);
CoreDamageTypes damageTypes2 = CoreDamageTypes.None;
DamageCategory damageCategory = DamageCategory.Normal;
healthHaver3.ApplyDamage(damage, direction, enemiesString, damageTypes2, damageCategory, false, null, ignoreDamageCaps);
if (data.IsChandelierExplosion && (!healthHaver || healthHaver.healthHaver.IsDead))
{
GameStatsManager.Instance.RegisterStatChange(TrackedStats.ENEMIES_KILLED_WITH_CHANDELIERS, 1f);
}
}
flag = true;
}
if (isFreezeExplosion && num < data.freezeRadius)
{
if (healthHaver && healthHaver.gameActor != null && !healthHaver.IsDead && (!healthHaver.aiActor || !healthHaver.aiActor.IsGone))
{
healthHaver.gameActor.ApplyEffect(data.freezeEffect, 1f, null);
}
flag = true;
}
if (data.doForce && num < data.pushRadius)
{
KnockbackDoer knockbackDoer = healthHaver.knockbackDoer;
if (knockbackDoer)
{
float num2 = 1f - num / data.pushRadius;
if (data.preventPlayerForce && healthHaver.GetComponent <PlayerController>())
{
num2 = 0f;
}
knockbackDoer.ApplyKnockback(vector.normalized, num2 * data.force, false);
}
flag = true;
}
if (flag)
{
break;
}
}
IL_A6E :;
}
}
}
}
IL_A82 :;
}
}
List <MinorBreakable> allBreakables = StaticReferenceManager.AllMinorBreakables;
if (allBreakables != null)
{
for (int l = 0; l < allBreakables.Count; l++)
{
MinorBreakable minorBreakable = allBreakables[l];
if (minorBreakable)
{
if (!minorBreakable.resistsExplosions)
{
if (!minorBreakable.OnlyBrokenByCode)
{
Vector2 vector2 = minorBreakable.CenterPoint - position.XY();
if (vector2.sqrMagnitude < pushSqrRadius)
{
minorBreakable.Break(vector2.normalized);
}
}
}
}
}
}
if (data.doDestroyProjectiles)
{
float duration = 0.2f;
PlayerController bestActivePlayer = GameManager.Instance.BestActivePlayer;
if (bestActivePlayer && bestActivePlayer.CurrentRoom != null && bestActivePlayer.CurrentRoom.area != null && bestActivePlayer.CurrentRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS)
{
duration = 0.035f;
}
GameManager.Instance.Dungeon.StartCoroutine(HandleBulletDeletionFrames(position, bulletDeletionSqrRadius, duration));
}
if (data.doDamage || data.breakSecretWalls)
{
List <MajorBreakable> allMajorBreakables = StaticReferenceManager.AllMajorBreakables;
if (allMajorBreakables != null)
{
for (int m = 0; m < allMajorBreakables.Count; m++)
{
MajorBreakable majorBreakable = allMajorBreakables[m];
if (majorBreakable)
{
if (majorBreakable.enabled)
{
if (!majorBreakable.IgnoreExplosions)
{
Vector2 sourceDirection = majorBreakable.CenterPoint - position.XY();
if (sourceDirection.sqrMagnitude < pushSqrRadius && (!majorBreakable.IsSecretDoor || !data.forcePreventSecretWallDamage))
{
if (data.doDamage)
{
majorBreakable.ApplyDamage(data.damage, sourceDirection, false, true, false);
}
if (data.breakSecretWalls && majorBreakable.IsSecretDoor)
{
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
StaticReferenceManager.AllMajorBreakables[m].ApplyDamage(1E+10f, Vector2.zero, false, true, true);
}
}
}
}
}
}
}
}
if (data.doForce)
{
Exploder.DoRadialPush(position, data.debrisForce, data.pushRadius);
}
if (data.doScreenShake && GameManager.Instance.MainCameraController != null)
{
GameManager.Instance.MainCameraController.DoScreenShake(data.ss, new Vector2?(position), false);
}
if (data.doStickyFriction && GameManager.Instance.MainCameraController != null)
{
StickyFrictionManager.Instance.RegisterExplosionStickyFriction();
}
for (int n = 0; n < StaticReferenceManager.AllRatTrapdoors.Count; n++)
{
if (StaticReferenceManager.AllRatTrapdoors[n])
{
StaticReferenceManager.AllRatTrapdoors[n].OnNearbyExplosion(position);
}
}
Destroy(this.gameObject);
yield break;
}
private static void HandleHeroSwordSlash(List <SpeculativeRigidbody> alreadyHit, Vector2 arcOrigin, float slashAngle, int slashId, GameActor owner, SlashData slashParameters)
{
float degreesOfSlash = slashParameters.slashDegrees;
float slashRange = slashParameters.slashRange;
ReadOnlyCollection <Projectile> allProjectiles2 = StaticReferenceManager.AllProjectiles;
for (int j = allProjectiles2.Count - 1; j >= 0; j--)
{
Projectile projectile2 = allProjectiles2[j];
if (ProjectileIsValid(projectile2, owner))
{
Vector2 projectileCenter = projectile2.sprite.WorldCenter;
if (ObjectWasHitBySlash(projectileCenter, arcOrigin, slashAngle, slashRange, degreesOfSlash))
{
if (slashParameters.OnHitBullet != null)
{
slashParameters.OnHitBullet(projectile2);
}
if (slashParameters.projInteractMode != ProjInteractMode.IGNORE || projectile2.collidesWithProjectiles)
{
if (slashParameters.projInteractMode == ProjInteractMode.DESTROY || slashParameters.projInteractMode == ProjInteractMode.IGNORE)
{
projectile2.DieInAir(false, true, true, true);
}
else if (slashParameters.projInteractMode == ProjInteractMode.REFLECT || slashParameters.projInteractMode == ProjInteractMode.REFLECTANDPOSTPROCESS)
{
if (projectile2.Owner != null && projectile2.LastReflectedSlashId != slashId)
{
projectile2.ReflectBullet(true, owner, 5, (slashParameters.projInteractMode == ProjInteractMode.REFLECTANDPOSTPROCESS), 1, 5, 0, null);
projectile2.LastReflectedSlashId = slashId;
}
}
}
}
}
}
DealDamageToEnemiesInArc(owner, arcOrigin, slashAngle, slashRange, slashParameters, alreadyHit);
if (slashParameters.damagesBreakables)
{
List <MinorBreakable> allMinorBreakables = StaticReferenceManager.AllMinorBreakables;
for (int k = allMinorBreakables.Count - 1; k >= 0; k--)
{
MinorBreakable minorBreakable = allMinorBreakables[k];
if (minorBreakable && minorBreakable.specRigidbody)
{
if (!minorBreakable.IsBroken && minorBreakable.sprite)
{
if (ObjectWasHitBySlash(minorBreakable.sprite.WorldCenter, arcOrigin, slashAngle, slashRange, degreesOfSlash))
{
if (slashParameters.OnHitMinorBreakable != null)
{
slashParameters.OnHitMinorBreakable(minorBreakable);
}
minorBreakable.Break();
}
}
}
}
List <MajorBreakable> allMajorBreakables = StaticReferenceManager.AllMajorBreakables;
for (int l = allMajorBreakables.Count - 1; l >= 0; l--)
{
MajorBreakable majorBreakable = allMajorBreakables[l];
if (majorBreakable && majorBreakable.specRigidbody)
{
if (!alreadyHit.Contains(majorBreakable.specRigidbody))
{
if (!majorBreakable.IsSecretDoor && !majorBreakable.IsDestroyed)
{
if (ObjectWasHitBySlash(majorBreakable.specRigidbody.UnitCenter, arcOrigin, slashAngle, slashRange, degreesOfSlash))
{
float num9 = slashParameters.damage;
if (majorBreakable.healthHaver)
{
num9 *= 0.2f;
}
if (slashParameters.OnHitMajorBreakable != null)
{
slashParameters.OnHitMajorBreakable(majorBreakable);
}
majorBreakable.ApplyDamage(num9, majorBreakable.specRigidbody.UnitCenter - arcOrigin, false, false, false);
alreadyHit.Add(majorBreakable.specRigidbody);
}
}
}
}
}
}
}
public static GameObject MainHook(GameObject objectToInstantiate, RoomHandler targetRoom,
IntVector2 location, bool deferConfiguration, AIActor.AwakenAnimationType awakenAnimType = AIActor.AwakenAnimationType.Default, bool autoEngage = false)
{ //hooks into InstantiateDungeonPlaceable
GameObject result;
System.Random rnd = new System.Random();
int nu = 0;
string enemyGuid;
GRandomHook.wasBoss = false;
bool isbossroom = false;
if (targetRoom.area.PrototypeRoomCategory == PrototypeDungeonRoom.RoomCategory.BOSS &&
targetRoom.area.PrototypeRoomBossSubcategory == PrototypeDungeonRoom.RoomBossSubCategory.FLOOR_BOSS)
{
isbossroom = true;
}
else if (GRandomRoomDatabaseHelper.AllSpecificDeathRooms.Contains(targetRoom.GetRoomName()))
{
isbossroom = true;
}
try
{
if (objectToInstantiate != null)
{
Vector3 vector = location.ToVector3(0f) + targetRoom.area.basePosition.ToVector3();
vector.z = vector.y + vector.z;
AIActor component = objectToInstantiate.GetComponent <AIActor>(); //notused
AIActor ogcomponent = component;
if (component is AIActorDummy)
{
objectToInstantiate = (component as AIActorDummy).realPrefab;
component = objectToInstantiate.GetComponent <AIActor>();
}
SpeculativeRigidbody component2 = objectToInstantiate.GetComponent <SpeculativeRigidbody>(); //notused
if (component && component2)
{
if (component.EnemyGuid != null)
{
//Here gets enemyGuid based on room. Pulls from EnemyDatabase ///////////////////////
if (isbossroom)
{
if (component.healthHaver.IsBoss)
{
GRandomHook.wasBoss = true;
if (component.healthHaver.GetMaxHealth() != 60) //sometimes gets health as regular enemy health, 60
{
GRandomHook.boss_health = component.healthHaver.GetMaxHealth();
//getting boss health to set for replacement boss
}
//replacement for Boss
nu = rnd.Next(0, GRandomEnemyDataBaseHelper.UsedBossRoomDatabase.Count);
enemyGuid = GRandomEnemyDataBaseHelper.UsedBossRoomDatabase[nu];
}
else
{ //normal enemies as bosses is off and the enemy is not a boss; pull from no bosses database for enemy spawnings
nu = rnd.Next(0, GRandomEnemyDataBaseHelper.BossRoomRegularEnemiesOnly.Count);
enemyGuid = GRandomEnemyDataBaseHelper.BossRoomRegularEnemiesOnly[nu];
}
}
else if (targetRoom.GetRoomName() == "ResourcefulRat_PitEntrance_01" | targetRoom.GetRoomName() == "ResourcefulRat_Entrance")
{
nu = rnd.Next(0, GRandomEnemyDataBaseHelper.HarmlessEnemyDatabase.Count);
enemyGuid = GRandomEnemyDataBaseHelper.HarmlessEnemyDatabase[nu];
}
else
{
nu = rnd.Next(0, GRandomEnemyDataBaseHelper.UsedRegularRoomDatabase.Count);
enemyGuid = GRandomEnemyDataBaseHelper.UsedRegularRoomDatabase[nu];
}
if (component.EnemyGuid == "479556d05c7c44f3b6abb3b2067fc778") //wallmimic
{
enemyGuid = "479556d05c7c44f3b6abb3b2067fc778";
}
//
//can add specific Guid here for debugging
//
if (enemyGuid == "465da2bb086a4a88a803f79fe3a27677") //replace DraGun, can't remove him from database or forge dragunroom breaks
{
enemyGuid = "05b8afe0b6cc4fffa9dc6036fa24c8ec";
}
// End getting guid //////////////////////////////
//initializing new AIActor, not sure why they do it again below
AIActor prefabActor = EnemyDatabase.GetOrLoadByGuid(enemyGuid);
objectToInstantiate = prefabActor.gameObject;
component = objectToInstantiate.GetComponent <AIActor>();
component2 = objectToInstantiate.GetComponent <SpeculativeRigidbody>();
//bool specificdeathdoer = prefabActor.healthHaver.ManualDeathHandling;
GenericIntroDoer genericIntroDoer = component.GetComponent <GenericIntroDoer>();
//if (genericIntroDoer) // is boss
// handles initiated boss settings
if (component.healthHaver.IsBoss)
{
if (isbossroom)
{
prefabActor.healthHaver.SetHealthMaximum(GRandomHook.boss_health);
ETGModConsole.Log("Newbosshealth " + prefabActor.healthHaver.GetMaxHealth());
}
else
{
prefabActor.healthHaver.SetHealthMaximum(60f);
}
objectToInstantiate = RandomHandleEnemyInfo.RemoveBossIntros(objectToInstantiate);
objectToInstantiate = RandomHandleEnemyInfo.ReplaceSpecificBossDeathController(objectToInstantiate);
objectToInstantiate = RandomHandleEnemyInfo.AttackBehaviorManipulator(objectToInstantiate);
DemonWallController dwc = objectToInstantiate.GetComponent <DemonWallController>();
if (dwc)
{
Destroy(dwc);
}
}
if (!component.IsNormalEnemy)
{
objectToInstantiate = RandomHandleEnemyInfo.HandleCompanions(objectToInstantiate);
}
}
PixelCollider pixelCollider = component2.GetPixelCollider(ColliderType.Ground);
if (pixelCollider.ColliderGenerationMode != PixelCollider.PixelColliderGeneration.Manual)
{
Debug.LogErrorFormat("Trying to spawn an AIActor who doesn't have a manual ground collider... do we still do this? Name: {0}", new object[]
{
objectToInstantiate.name
});
}
Vector2 a = PhysicsEngine.PixelToUnit(new IntVector2(pixelCollider.ManualOffsetX, pixelCollider.ManualOffsetY));
Vector2 vector2 = PhysicsEngine.PixelToUnit(new IntVector2(pixelCollider.ManualWidth, pixelCollider.ManualHeight));
Vector2 vector3 = new Vector2((float)Mathf.CeilToInt(vector2.x), (float)Mathf.CeilToInt(vector2.y));
Vector2 b = new Vector2((vector3.x - vector2.x) / 2f, 0f).Quantize(0.0625f);
if (targetRoom.GetRoomName() == "DraGunRoom01" | targetRoom.GetRoomName() == "LichRoom02" |
targetRoom.GetRoomName() == "LichRoom03" | targetRoom.GetRoomName() == "Bullet_End_Room_04" |
targetRoom.GetRoomName() == "ResourcefulRatRoom01")
{
b -= new Vector2(0.0f, 5.0f);
}
Vector3 v3 = a - b;
vector -= v3;
//vector -= a - b; //Vector3
}
if (component)
{
component.AwakenAnimType = awakenAnimType;
}
GameObject NewEnemyObject = UnityEngine.Object.Instantiate <GameObject>(objectToInstantiate, vector, Quaternion.identity);
if (!deferConfiguration)
{
Component[] componentsInChildren = NewEnemyObject.GetComponentsInChildren(typeof(IPlaceConfigurable));
for (int i = 0; i < componentsInChildren.Length; i++)
{
IPlaceConfigurable placeConfigurable = componentsInChildren[i] as IPlaceConfigurable;
if (placeConfigurable != null)
{
placeConfigurable.ConfigureOnPlacement(targetRoom);
}
}
}
ObjectVisibilityManager component3 = NewEnemyObject.GetComponent <ObjectVisibilityManager>();
if (component3 != null)
{
component3.Initialize(targetRoom, autoEngage);
}
MinorBreakable componentInChildren = NewEnemyObject.GetComponentInChildren <MinorBreakable>();
if (componentInChildren != null)
{
IntVector2 key = location + targetRoom.area.basePosition;
CellData cellData = GameManager.Instance.Dungeon.data[key];
if (cellData != null)
{
cellData.cellVisualData.containsObjectSpaceStamp = true;
}
}
PlayerItem component4 = NewEnemyObject.GetComponent <PlayerItem>();
if (component4 != null)
{
component4.ForceAsExtant = true;
}
//[Randomizer] Add AIActor GameObjectInfo
AIActor enemy_component = NewEnemyObject.GetComponent <AIActor>();
if (enemy_component)
{
if (enemy_component.healthHaver.IsBoss)
{
if (isbossroom)
{ //Boss Room
enemy_component.healthHaver.bossHealthBar = HealthHaver.BossBarType.MainBar;
}
else
{
enemy_component.healthHaver.bossHealthBar = HealthHaver.BossBarType.None;
autoEngage = true;
}
NewEnemyObject = RandomHandleEnemyInfo.ReinstateBossObjectInfo(NewEnemyObject); //removes boss status if regular boss, needs hitbox stuff reinstated
}
if (GRandomEnemyDataBaseHelper.SpecificEnemyDatabase.Contains(enemy_component.EnemyGuid))
{
NewEnemyObject = RandomHandleEnemyInfo.SpecificEnemyHelper(NewEnemyObject);
}
NewEnemyObject = UniqueBossRoomDeathHandler.SpecificRoomHandler(targetRoom, NewEnemyObject);
}
result = NewEnemyObject;
}
else
{
result = null;
//return null;
}
}
catch (Exception message)
{
Debug.Log("[RANDOMIZER ERROR] " + message.ToString());
result = null;
}
return(result);
}
private static void HandleHeroSwordSlash(List <SpeculativeRigidbody> alreadyHit, Vector2 arcOrigin, float slashAngle, int slashId, PlayerController owner, ProjInteractMode intmode, float damageToDeal, float enemyKnockback, List <GameActorEffect> statusEffects, float jammedDMGMult, float bossDMGMult, float slashRange, float slashDimensions)
{
ReadOnlyCollection <Projectile> allProjectiles2 = StaticReferenceManager.AllProjectiles;
for (int j = allProjectiles2.Count - 1; j >= 0; j--)
{
Projectile projectile2 = allProjectiles2[j];
if (ProjectileIsValid(projectile2))
{
Vector2 projectileCenter = projectile2.sprite.WorldCenter;
if (ObjectWasHitBySlash(projectileCenter, arcOrigin, slashAngle, slashRange, slashDimensions))
{
if (intmode != ProjInteractMode.IGNORE || projectile2.collidesWithProjectiles)
{
if (intmode == ProjInteractMode.DESTROY || intmode == ProjInteractMode.IGNORE)
{
projectile2.DieInAir(false, true, true, true);
}
else if (intmode == ProjInteractMode.REFLECT)
{
if (projectile2.LastReflectedSlashId != slashId)
{
PassiveReflectItem.ReflectBullet(projectile2, true, owner, 2f, 1f, 1f, 0f);
projectile2.LastReflectedSlashId = slashId;
}
}
}
}
}
}
DealDamageToEnemiesInArc(owner, arcOrigin, slashAngle, slashRange, damageToDeal, enemyKnockback, statusEffects, jammedDMGMult, bossDMGMult, slashDimensions, alreadyHit);
List <MinorBreakable> allMinorBreakables = StaticReferenceManager.AllMinorBreakables;
for (int k = allMinorBreakables.Count - 1; k >= 0; k--)
{
MinorBreakable minorBreakable = allMinorBreakables[k];
if (minorBreakable && minorBreakable.specRigidbody)
{
if (!minorBreakable.IsBroken && minorBreakable.sprite)
{
if (ObjectWasHitBySlash(minorBreakable.sprite.WorldCenter, arcOrigin, slashAngle, slashRange, slashDimensions))
{
minorBreakable.Break();
}
}
}
}
List <MajorBreakable> allMajorBreakables = StaticReferenceManager.AllMajorBreakables;
for (int l = allMajorBreakables.Count - 1; l >= 0; l--)
{
MajorBreakable majorBreakable = allMajorBreakables[l];
if (majorBreakable && majorBreakable.specRigidbody)
{
if (!alreadyHit.Contains(majorBreakable.specRigidbody))
{
if (!majorBreakable.IsSecretDoor && !majorBreakable.IsDestroyed)
{
if (ObjectWasHitBySlash(majorBreakable.specRigidbody.UnitCenter, arcOrigin, slashAngle, slashRange, slashDimensions))
{
float num9 = damageToDeal;
if (majorBreakable.healthHaver)
{
num9 *= 0.2f;
}
majorBreakable.ApplyDamage(num9, majorBreakable.specRigidbody.UnitCenter - arcOrigin, false, false, false);
alreadyHit.Add(majorBreakable.specRigidbody);
}
}
}
}
}
}
private void HandleBroken(MinorBreakable mb)
{
PlayerController player = this.Owner;
if (player.HasPickupID(532) || player.HasPickupID(214))
{
float value = UnityEngine.Random.Range(0.0f, 1.0f);
if (value < 0.1)
{
LootEngine.SpawnItem(PickupObjectDatabase.GetById(68).gameObject, mb.sprite.WorldCenter, Vector2.zero, 1f, false, false, false);
}
}
if (player.CurrentRoom.HasActiveEnemies(RoomHandler.ActiveEnemyType.All))
{
if (mb && mb != null)
{
float num = 10f;
List <AIActor> activeEnemies = this.Owner.CurrentRoom.GetActiveEnemies(RoomHandler.ActiveEnemyType.All);
bool flag3 = activeEnemies == null | activeEnemies.Count <= 0;
bool flag4 = !flag3;
if (flag4)
{
AIActor nearestEnemy = this.GetNearestEnemy(activeEnemies, mb.sprite.WorldCenter, out num, null);
if (nearestEnemy && nearestEnemy != null)
{
if (player.HasPickupID(152) && player.CurrentGun.PickupObjectId == 152)
{
Vector2 unitCenter = mb.sprite.WorldCenter;
Vector2 unitCenter2 = nearestEnemy.specRigidbody.HitboxPixelCollider.UnitCenter;
float z = BraveMathCollege.Atan2Degrees((unitCenter2 - unitCenter).normalized);
Projectile projectile = ((Gun)ETGMod.Databases.Items[152]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, mb.sprite.WorldCenter, Quaternion.Euler(0f, 0f, z), true);
Projectile component = gameObject.GetComponent <Projectile>();
bool flag11 = component != null;
if (flag11)
{
component.Owner = player;
component.baseData.range *= 5f;
component.pierceMinorBreakables = true;
component.collidesWithPlayer = false;
}
}
if (player.HasPickupID(7))
{
Vector2 unitCenter = mb.sprite.WorldCenter;
Vector2 unitCenter2 = nearestEnemy.specRigidbody.HitboxPixelCollider.UnitCenter;
float z = BraveMathCollege.Atan2Degrees((unitCenter2 - unitCenter).normalized);
Projectile projectile = ((Gun)ETGMod.Databases.Items[7]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, mb.sprite.WorldCenter, Quaternion.Euler(0f, 0f, z), true);
Projectile component = gameObject.GetComponent <Projectile>();
bool flag11 = component != null;
if (flag11)
{
component.Owner = player;
component.baseData.range *= 5f;
component.pierceMinorBreakables = true;
component.collidesWithPlayer = false;
}
}
else if (!player.HasPickupID(7) && player.CurrentGun.PickupObjectId != 152)
{
Vector2 unitCenter = mb.sprite.WorldCenter;
Vector2 unitCenter2 = nearestEnemy.specRigidbody.HitboxPixelCollider.UnitCenter;
float z = BraveMathCollege.Atan2Degrees((unitCenter2 - unitCenter).normalized);
Projectile projectile = ((Gun)ETGMod.Databases.Items[15]).DefaultModule.projectiles[0];
GameObject gameObject = SpawnManager.SpawnProjectile(projectile.gameObject, mb.sprite.WorldCenter, Quaternion.Euler(0f, 0f, z), true);
Projectile component = gameObject.GetComponent <Projectile>();
bool flag11 = component != null;
if (flag11)
{
component.Owner = player;
component.baseData.range *= 5f;
component.pierceMinorBreakables = true;
component.collidesWithPlayer = false;
}
}
}
else
{
return;
}
}
}
}
}
private void Start()
{
PlayerReflection.TargetPlayer = GameManager.Instance.PrimaryPlayer;
PlayerReflection.MirrorSprite = MirrorSprite;
if (!isGlitched)
{
if (GameManager.Instance.CurrentGameType == GameManager.GameType.COOP_2_PLAYER)
{
CoopPlayerReflection.TargetPlayer = GameManager.Instance.SecondaryPlayer;
CoopPlayerReflection.MirrorSprite = MirrorSprite;
}
else
{
CoopPlayerReflection.gameObject.SetActive(false);
}
}
else
{
PlayerReflection.gameObject.SetActive(false);
CoopPlayerReflection.gameObject.SetActive(false);
tk2dBaseSprite[] AllMirrorSprites = gameObject.GetComponents <tk2dBaseSprite>();
if (AllMirrorSprites != null && AllMirrorSprites.Length > 0)
{
ChaosShaders.Instance.ApplyGlitchShader(null, AllMirrorSprites[0]);
}
}
IntVector2 MirrorChestPosition = (base.transform.position.IntXY(VectorConversions.Round) + new IntVector2(0, -2) - m_ParentRoom.area.basePosition);
if (spawnBellosChest)
{
MirrorChest = ChaosUtility.GenerateChest(MirrorChestPosition, m_ParentRoom, PickupObject.ItemQuality.A, 0, false);
MirrorChest.forceContentIds = new List <int>()
{
435, 493
};
}
else
{
MirrorChest = ChaosUtility.GenerateChest(MirrorChestPosition, m_ParentRoom, null, -1f);
}
MirrorChest.PreventFuse = true;
SpriteOutlineManager.RemoveOutlineFromSprite(MirrorChest.sprite, false);
Transform transform = MirrorChest.gameObject.transform.Find("Shadow");
if (transform)
{
MirrorChest.ShadowSprite = transform.GetComponent <tk2dSprite>();
}
MirrorChest.IsMirrorChest = true;
MirrorChest.ConfigureOnPlacement(m_ParentRoom);
m_ParentRoom.RegisterInteractable(MirrorChest);
if (spawnBellosChest)
{
MirrorChest.DeregisterChestOnMinimap();
}
if (MirrorChest.majorBreakable)
{
MirrorChest.majorBreakable.TemporarilyInvulnerable = true;
}
ChestSprite = MirrorChest.sprite;
ChestSprite.renderer.enabled = false;
ChestReflection.TargetSprite = ChestSprite;
ChestReflection.MirrorSprite = MirrorSprite;
SpeculativeRigidbody specRigidbody = MirrorSprite.specRigidbody;
specRigidbody.OnRigidbodyCollision = (SpeculativeRigidbody.OnRigidbodyCollisionDelegate)Delegate.Combine(specRigidbody.OnRigidbodyCollision, new SpeculativeRigidbody.OnRigidbodyCollisionDelegate(HandleRigidbodyCollisionWithMirror));
MinorBreakable componentInChildren = GetComponentInChildren <MinorBreakable>();
componentInChildren.OnlyBrokenByCode = true;
componentInChildren.heightOffGround = 4f;
IPlayerInteractable[] TableInterfacesInChildren = GameObjectExtensions.GetInterfacesInChildren <IPlayerInteractable>(gameObject);
for (int i = 0; i < TableInterfacesInChildren.Length; i++)
{
if (!m_ParentRoom.IsRegistered(TableInterfacesInChildren[i]))
{
m_ParentRoom.RegisterInteractable(TableInterfacesInChildren[i]);
}
}
// Destroy(gameObject.GetComponent<MirrorController>());
// SpeculativeRigidbody InteractableRigidMirror = gameObject.GetComponent<SpeculativeRigidbody>();
// InteractableRigidMirror.Initialize();
// PhysicsEngine.Instance.RegisterOverlappingGhostCollisionExceptions(InteractableRigidMirror, null, false);
}
