public static void DoRadialMajorBreakableDamage(float damage, Vector3 position, float radius)
{
List <MajorBreakable> allMajorBreakables = StaticReferenceManager.AllMajorBreakables;
float num = radius * radius;
if (allMajorBreakables != null)
{
for (int i = 0; i < allMajorBreakables.Count; i++)
{
MajorBreakable majorBreakable = allMajorBreakables[i];
if (majorBreakable)
{
if (majorBreakable.enabled)
{
if (!majorBreakable.IgnoreExplosions)
{
Vector2 sourceDirection = majorBreakable.CenterPoint - position.XY();
if (sourceDirection.sqrMagnitude < num)
{
majorBreakable.ApplyDamage(damage, sourceDirection, false, true, false);
}
}
}
}
}
}
}
public void OpenAsRickRoll(PlayerController player)
{
if (player)
{
if (m_registeredIconRoom != null)
{
Minimap.Instance.DeregisterRoomIcon(m_registeredIconRoom, minimapIconInstance);
}
m_Opened = true;
m_room.DeregisterInteractable(this);
MajorBreakable component = GetComponent <MajorBreakable>();
if (component)
{
component.usesTemporaryZeroHitPointsState = false;
}
AkSoundEngine.PostEvent("play_obj_chest_open_01", gameObject);
spriteAnimator.Play(openAnimName);
player.TriggerItemAcquisition();
if (majorBreakable)
{
majorBreakable.OnBreak = (Action)Delegate.Remove(majorBreakable.OnBreak, new Action(OnBroken));
majorBreakable.SpawnItemOnBreak = false;
}
if (m_room.area.PrototypeRoomCategory != PrototypeDungeonRoom.RoomCategory.SECRET)
{
StartCoroutine(SpwanEnemyAirDrop());
}
StartCoroutine(DoRickRoll());
}
}
protected void Initialize()
{
specRigidbody.Initialize();
specRigidbody.PreventPiercing = true;
MajorBreakable component = GetComponent <MajorBreakable>();
if (component)
{
MajorBreakable majorBreakable = component;
majorBreakable.OnBreak = (Action)Delegate.Combine(majorBreakable.OnBreak, new Action(OnBroken));
}
IntVector2 intVector = specRigidbody.UnitBottomLeft.ToIntVector2(VectorConversions.Floor);
IntVector2 intVector2 = specRigidbody.UnitTopRight.ToIntVector2(VectorConversions.Floor);
for (int i = intVector.x; i <= intVector2.x; i++)
{
for (int j = intVector.y; j <= intVector2.y; j++)
{
GameManager.Instance.Dungeon.data[new IntVector2(i, j)].isOccupied = true;
}
}
// Become Rainbow
sprite.usesOverrideMaterial = true;
sprite.renderer.material.shader = ShaderCache.Acquire("Brave/Internal/RainbowChestShader");
}
private IEnumerator ResetInvul(MajorBreakable breakable)
{
yield return(new WaitForSeconds(0.1f));
breakable.TemporarilyInvulnerable = false;
yield break;
}
public void Start()
{
if (base.majorBreakable != null)
{
MajorBreakable majorBreakable = base.majorBreakable;
majorBreakable.OnBreak = (Action)Delegate.Combine(majorBreakable.OnBreak, new Action(OnBroken));
}
}
private void Update()
{
if (Configured)
{
MajorBreakable m_Breakable = majorBreakable;
if (m_Breakable)
{
m_Breakable.OnBreak += OnBrokenInSadness;
}
Configured = false;
}
}
private void Awake()
{
SpriteOutlineManager.AddOutlineToSprite(sprite, BaseOutlineColor, 0.1f, 0f, SpriteOutlineManager.OutlineType.NORMAL);
if (!isMusicSwitch)
{
MajorBreakable breakable = majorBreakable;
if (breakable && breakable.DamageReduction > 1000f)
{
breakable.ReportZeroDamage = true;
}
// base.majorBreakable.InvulnerableToEnemyBullets = true;
}
}
private void HandleRigidbodyCollision(CollisionData rigidbodyCollision)
{
AIActor component = rigidbodyCollision.OtherRigidbody.GetComponent <AIActor>();
bool flag = false;
if (component && component.IsNormalEnemy && component.healthHaver && component.healthHaver.IsVulnerable)
{
if (component.FlagToSetOnDeath == GungeonFlags.BOSSKILLED_DEMONWALL)
{
flag = true;
component.healthHaver.ApplyDamage(35f, rigidbodyCollision.Normal * -1f, "nom nom", CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
else if (component.healthHaver.IsBoss)
{
flag = true;
component.healthHaver.ApplyDamage(35f, rigidbodyCollision.Normal * -1f, "nom nom", CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
else
{
flag = true;
component.healthHaver.ApplyDamage(20f, rigidbodyCollision.Normal * -1f, "nom nom", CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
}
else
{
MajorBreakable component3 = rigidbodyCollision.OtherRigidbody.GetComponent <MajorBreakable>();
BodyPartController component4 = rigidbodyCollision.OtherRigidbody.GetComponent <BodyPartController>();
if (component4 && component3)
{
flag = true;
Vector2 normalized = (rigidbodyCollision.MyRigidbody.UnitCenter - rigidbodyCollision.OtherRigidbody.UnitCenter).normalized;
component3.ApplyDamage(20f, normalized * -1f, false, false, false);
if (component3.healthHaver)
{
component3.healthHaver.ApplyDamage(20f, normalized * -1f, "nom nom", CoreDamageTypes.None, DamageCategory.Normal, false, null, false);
}
}
}
if (flag)
{
rigidbodyCollision.MyRigidbody.RegisterTemporaryCollisionException(rigidbodyCollision.OtherRigidbody, 0.5f, null);
}
}
public void Open(PlayerController player)
{
if (player)
{
if (m_registeredIconRoom != null)
{
Minimap.Instance.DeregisterRoomIcon(m_registeredIconRoom, minimapIconInstance);
}
m_Opened = true;
// IsOpen = true;
m_room.DeregisterInteractable(this);
MajorBreakable component = GetComponent <MajorBreakable>();
if (component)
{
component.usesTemporaryZeroHitPointsState = false;
}
AkSoundEngine.PostEvent("play_obj_chest_open_01", gameObject);
spriteAnimator.Play(openAnimName);
player.TriggerItemAcquisition();
StartCoroutine(DoRickRoll());
}
}
private IEnumerator HandleDelayedTableExplosion(FlippableCover sourceTable, SpeculativeRigidbody flipperSource, float delay)
{
yield return(new WaitForSeconds(delay));
if (sourceTable.sprite)
{
Vector2 ExplosionCenterPosition = sourceTable.sprite.WorldCenter;
if (sourceTable.specRigidbody)
{
sourceTable.specRigidbody.CollideWithOthers = false;
}
MajorBreakable breakable = sourceTable.GetComponentInChildren <MajorBreakable>();
if (breakable)
{
breakable.ApplyDamage(90, Vector2.zero, false, true, false);
}
Exploder.Explode(ExplosionCenterPosition, TableExplosionData, Vector2.zero, null, false, CoreDamageTypes.None, false);
}
else if (sourceTable.specRigidbody)
{
Vector2 ExplosionCenterPosition = sourceTable.transform.position;
if (sourceTable.specRigidbody)
{
sourceTable.specRigidbody.CollideWithOthers = false;
}
MajorBreakable breakable = sourceTable.GetComponentInChildren <MajorBreakable>();
if (breakable)
{
breakable.ApplyDamage(90, Vector2.zero, false, true, false);
}
Exploder.Explode(ExplosionCenterPosition, TableExplosionData, Vector2.zero, null, false, CoreDamageTypes.None, false);
}
yield break;
}
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 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);
}
}
}
}
}
}
}
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;
}
protected void Initialize()
{
specRigidbody.Initialize();
specRigidbody.PreventPiercing = true;
MajorBreakable component = gameObject.GetComponent <MajorBreakable>();
switch (chestType)
{
case ChestType.MusicSwitch:
return;
case ChestType.RickRoll:
if (component)
{
MajorBreakable majorBreakable = component;
majorBreakable.OnBreak = (Action)Delegate.Combine(majorBreakable.OnBreak, new Action(OnBroken));
}
IntVector2 intVector = specRigidbody.UnitBottomLeft.ToIntVector2(VectorConversions.Floor);
IntVector2 intVector2 = specRigidbody.UnitTopRight.ToIntVector2(VectorConversions.Floor);
for (int i = intVector.x; i <= intVector2.x; i++)
{
for (int j = intVector.y; j <= intVector2.y; j++)
{
GameManager.Instance.Dungeon.data[new IntVector2(i, j)].isOccupied = true;
}
}
sprite.usesOverrideMaterial = true;
sprite.renderer.material.shader = ShaderCache.Acquire("Brave/Internal/RainbowChestShader");
return;
case ChestType.SurpriseChest:
if (component)
{
MajorBreakable majorBreakable = component;
majorBreakable.OnBreak = (Action)Delegate.Combine(majorBreakable.OnBreak, new Action(OnBroken));
}
IntVector2 intVector3 = specRigidbody.UnitBottomLeft.ToIntVector2(VectorConversions.Floor);
IntVector2 intVector4 = specRigidbody.UnitTopRight.ToIntVector2(VectorConversions.Floor);
for (int i = intVector3.x; i <= intVector4.x; i++)
{
for (int j = intVector3.y; j <= intVector4.y; j++)
{
GameManager.Instance.Dungeon.data[new IntVector2(i, j)].isOccupied = true;
}
}
spriteAnimator.Play("coop_chest_knock");
return;
case ChestType.WestChest:
if (component)
{
MajorBreakable majorBreakable = component;
majorBreakable.OnBreak = (Action)Delegate.Combine(majorBreakable.OnBreak, new Action(OnBroken));
}
IntVector2 intVector5 = specRigidbody.UnitBottomLeft.ToIntVector2(VectorConversions.Floor);
IntVector2 intVector6 = specRigidbody.UnitTopRight.ToIntVector2(VectorConversions.Floor);
for (int i = intVector5.x; i <= intVector6.x; i++)
{
for (int j = intVector5.y; j <= intVector6.y; j++)
{
GameManager.Instance.Dungeon.data[new IntVector2(i, j)].isOccupied = true;
}
}
return;
}
}
private IEnumerator DoRickRoll()
{
yield return(new WaitForSeconds(0.1f));
if (!m_room.IsSealed)
{
m_room.npcSealState = RoomHandler.NPCSealState.SealAll;
m_room.SealRoom();
}
GameObject m_RickRollInstance = Instantiate(RickRollAnimationObject, (transform.position + new Vector3(0.1f, 0.5f, 0)), Quaternion.identity);
Vector3 RickScale = new Vector2(0.2f, 0.2f).ToVector3ZUp(1f);
m_RickRollInstance.layer = LayerMask.NameToLayer("Unpixelated");
m_RickRollInstance.transform.localScale = RickScale;
MajorBreakable m_MajorBreakable = GetComponent <MajorBreakable>();
if (m_MajorBreakable)
{
m_MajorBreakable.TemporarilyInvulnerable = true;
}
if (sprite)
{
sprite.HeightOffGround = -2f; sprite.UpdateZDepth();
}
if (m_room.area.PrototypeRoomCategory != PrototypeDungeonRoom.RoomCategory.SECRET)
{
GameManager.Instance.StartCoroutine(SpwanEnemyAirDrop());
}
tk2dSpriteAnimator m_RickRollAnimator = m_RickRollInstance.GetComponent <tk2dSpriteAnimator>();
m_RickRollAnimator.Play("RickRollAnimation_Rise");
while (m_RickRollAnimator.IsPlaying("RickRollAnimation_Rise"))
{
yield return(null);
}
m_RickRollAnimator.Play("RickRollAnimation");
if (!ExpandStats.youtubeSafeMode)
{
AkSoundEngine.PostEvent("Play_EX_RickRollMusic_01", gameObject);
}
else
{
GameManager.Instance.StartCoroutine(DoYouTubeSafeAnnouncement(new Vector3(1.5f, 3.5f)));
}
yield return(new WaitForSeconds(10));
Destroy(m_RickRollInstance);
m_MajorBreakable.TemporarilyInvulnerable = false;
if (m_MajorBreakable)
{
MajorBreakable majorBreakable = m_MajorBreakable;
majorBreakable.OnBreak = (Action)Delegate.Remove(majorBreakable.OnBreak, new Action(OnBroken));
}
spriteAnimator.Play(breakAnimName);
specRigidbody.enabled = false;
IsBroken = true;
Transform shadowTransform = transform.Find("Expand_RickRollChestShadow");
if (shadowTransform != null)
{
Destroy(shadowTransform.gameObject);
}
m_Opened = true;
if (m_registeredIconRoom != null)
{
Minimap.Instance.DeregisterRoomIcon(m_registeredIconRoom, minimapIconInstance);
}
m_room.DeregisterInteractable(this);
if (m_room.npcSealState != RoomHandler.NPCSealState.SealNone)
{
m_room.npcSealState = RoomHandler.NPCSealState.SealNone;
}
Exploder.DoDefaultExplosion(sprite.WorldCenter, Vector2.zero, null, true, CoreDamageTypes.None, false);
yield break;
}
public void OnRigidbodyCollision(CollisionData data)
{
if ((data.OtherRigidbody.aiActor != null || data.OtherRigidbody.minorBreakable != null || data.OtherRigidbody.majorBreakable != null || data.OtherRigidbody.majorBreakable != null))
{
if (this.penetration <= 0 || data.OtherRigidbody.majorBreakable != null)
{
if (data.OtherRigidbody.aiActor != null)
{
if (data.OtherRigidbody.aiActor.healthHaver != null)
{
this.HandleEnemyDamage(data.OtherRigidbody, data.OtherPixelCollider);
}
}
else if (data.OtherRigidbody.minorBreakable != null)
{
data.OtherRigidbody.minorBreakable.Break();
}
else if (data.OtherRigidbody.majorBreakable != null)
{
MajorBreakable majorBreakable = data.OtherRigidbody.majorBreakable;
float num = 1f;
if (!majorBreakable.IsSecretDoor || !(this.m_owner.CurrentGun != null) || !this.m_owner.CurrentGun.InfiniteAmmo)
{
float num2 = this.damage;
if (num2 <= 0f && GameManager.Instance.InTutorial)
{
majorBreakable.ApplyDamage(1.5f, this.m_owner.specRigidbody.Velocity, false, false, false);
}
else
{
majorBreakable.ApplyDamage(num2 * num, this.m_owner.specRigidbody.Velocity, false, false, false);
}
}
}
if (data.OtherRigidbody.aiActor == null && this.bounces > 0)
{
Vector2 vector = data.Normal;
Vector2 velocity = data.MyRigidbody.Velocity;
float num2 = (-velocity).ToAngle();
float num3 = vector.ToAngle();
float num4 = BraveMathCollege.ClampAngle360(num2 + 2f * (num3 - num2));
this.degrees = num4;
this.bounces--;
}
else
{
this.ForceBreak();
}
}
}
else
{
if (this.bounces > 0)
{
Vector2 vector = data.Normal;
Vector2 velocity = data.MyRigidbody.Velocity;
float num2 = (-velocity).ToAngle();
float num3 = vector.ToAngle();
float num4 = BraveMathCollege.ClampAngle360(num2 + 2f * (num3 - num2));
this.degrees = num4;
this.bounces--;
}
else
{
this.ForceBreak();
}
}
}
