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(); } } }