public void BindWithRoom(Dungeonator.RoomHandler room)
 {
     room.Entered += delegate(PlayerController p)
     {
         base.StartCoroutine(this.Vanish(p));
     };
 }
Ejemplo n.º 2
0
 private void Coil_OnEnterAnyRoom(PlayerController arg1, Dungeonator.RoomHandler arg2)
 {
     if (arg1 && arg2 != null)
     {
         m_cable = arg1.gameObject.GetOrAddComponent <CoilHelper>();
         m_cable.Initialize(arg1.specRigidbody);
     }
 }
Ejemplo n.º 3
0
        public void Start()
        {
            Dungeonator.RoomHandler room        = GameManager.Instance.PrimaryPlayer.CurrentRoom;
            List <AIActor>          roomEnemies = room.GetActiveEnemies(Dungeonator.RoomHandler.ActiveEnemyType.All);

            foreach (AIActor enemy in roomEnemies)
            {
                if (enemy && enemy.healthHaver && enemy.healthHaver.IsBoss)
                {
                    enemy.healthHaver.SetHealthMaximum(enemy.healthHaver.GetMaxHealth() * healthMultiplier, null, true);
                }
            }
        }
Ejemplo n.º 4
0
        public void OnDestruction(Projectile projectile)
        {
            AIActor childAIActor = projectile.GetComponentInChildren <AIActor>();

            List <SpeculativeRigidbody> m_IgnoreRigidBodies = new List <SpeculativeRigidbody>();

            if (childAIActor)
            {
                childAIActor.specRigidbody.enabled = true;
                childAIActor.specRigidbody.HitboxPixelCollider.IsTrigger = true;
                childAIActor.specRigidbody.HitboxPixelCollider.CollisionLayerIgnoreOverride |= CollisionMask.LayerToMask(CollisionLayer.Projectile);
                childAIActor.specRigidbody.AddCollisionLayerIgnoreOverride(CollisionMask.LayerToMask(CollisionLayer.PlayerHitBox, CollisionLayer.PlayerCollider));
                childAIActor.sprite.UpdateZDepth();
                childAIActor.specRigidbody.UpdateCollidersOnScale    = true;
                childAIActor.specRigidbody.UpdateCollidersOnRotation = true;
                childAIActor.specRigidbody.Reinitialize();
                childAIActor.specRigidbody.OnPreRigidbodyCollision = (SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate)Delegate.Combine(childAIActor.specRigidbody.OnPreRigidbodyCollision, new SpeculativeRigidbody.OnPreRigidbodyCollisionDelegate(HandlePreCollision));

                if (m_FiresJammedEnemies && UnityEngine.Random.value <= 0.9f)
                {
                    childAIActor.CanDropCurrency = false;
                }

                Dungeonator.RoomHandler CurrentRoom = projectile.transform.position.GetAbsoluteRoom();

                if (childAIActor.EnemyGuid == "128db2f0781141bcb505d8f00f9e4d47" | childAIActor.EnemyGuid == "b54d89f9e802455cbb2b8a96a31e8259")
                {
                    childAIActor.healthHaver.spawnBulletScript = false;
                }

                if (CurrentRoom == null)
                {
                    childAIActor.gameObject.transform.parent = null;
                    if (childAIActor.gameObject.GetComponent <ExplodeOnDeath>() && childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData != null)
                    {
                        childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.ignoreList     = new List <SpeculativeRigidbody>();
                        childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.damageToPlayer = 0;
                        if (projectile.Owner && (projectile.Owner is PlayerController))
                        {
                            childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.ignoreList.Add(projectile.Owner.specRigidbody);
                        }
                    }
                    childAIActor.healthHaver.ApplyDamage(10000, Vector2.zero, "Self Destruct", CoreDamageTypes.None, DamageCategory.Unstoppable, true, ignoreDamageCaps: true);
                    return;
                }
                childAIActor.gameObject.transform.parent = CurrentRoom.hierarchyParent;
                float SurvivalOdds = 0.08f;
                if (m_FiresJammedEnemies)
                {
                    SurvivalOdds += 0.03f;
                }
                if (UnityEngine.Random.value <= SurvivalOdds && CurrentRoom.HasActiveEnemies(Dungeonator.RoomHandler.ActiveEnemyType.RoomClear))
                {
                    if (childAIActor.EnemyScale == Vector2.one)
                    {
                        childAIActor.procedurallyOutlined = true;
                    }
                    ;
                    ExpandUtility.CorrectForWalls(childAIActor);
                    childAIActor.CanTargetEnemies   = true;
                    childAIActor.CanTargetPlayers   = false;
                    childAIActor.IgnoreForRoomClear = true;

                    if (childAIActor.gameObject.GetComponent <ObjectVisibilityManager>())
                    {
                        childAIActor.gameObject.GetComponent <ObjectVisibilityManager>().Initialize(CurrentRoom, true);
                    }
                    if (childAIActor.bulletBank)
                    {
                        childAIActor.bulletBank.OnProjectileCreated = (Action <Projectile>)Delegate.Combine(childAIActor.bulletBank.OnProjectileCreated, new Action <Projectile>(HandleCompanionPostProcessProjectile));
                    }
                    if (childAIActor.aiShooter)
                    {
                        childAIActor.aiShooter.PostProcessProjectile = (Action <Projectile>)Delegate.Combine(childAIActor.aiShooter.PostProcessProjectile, new Action <Projectile>(HandleCompanionPostProcessProjectile));
                    }
                    childAIActor.ConfigureOnPlacement(CurrentRoom);
                    childAIActor.gameObject.AddComponent <KillOnRoomClear>();
                    return;
                }
                else
                {
                    if (CurrentRoom != null)
                    {
                        childAIActor.ConfigureOnPlacement(CurrentRoom);
                        childAIActor.gameObject.transform.parent = CurrentRoom.hierarchyParent;
                    }
                    else
                    {
                        childAIActor.gameObject.transform.parent = null;
                    }
                    if (childAIActor.gameObject.GetComponent <ExplodeOnDeath>() && childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData != null)
                    {
                        childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.ignoreList     = new List <SpeculativeRigidbody>();
                        childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.damageToPlayer = 0;
                        if (projectile.Owner && (projectile.Owner is PlayerController))
                        {
                            childAIActor.gameObject.GetComponent <ExplodeOnDeath>().explosionData.ignoreList.Add(projectile.Owner.specRigidbody);
                        }
                    }
                    childAIActor.healthHaver.ApplyDamage(10000, Vector2.zero, "Self Destruct", CoreDamageTypes.None, DamageCategory.Unstoppable, true, ignoreDamageCaps: true);
                    return;
                }
            }
        }
Ejemplo n.º 5
0
    void SpawnChest(string[] args)
    {
        if (!ArgCount(args, 1, 2))
        {
            return;
        }
        Dungeonator.RoomHandler currentRoom = GameManager.Instance.PrimaryPlayer.CurrentRoom;
        Chest  chest;
        bool   glitched = false;
        string name     = args[0].ToLower();

        switch (name)
        {
        case "brown":
        case "d":
            chest = GameManager.Instance.RewardManager.D_Chest;
            break;

        case "blue":
        case "c":
            chest = GameManager.Instance.RewardManager.C_Chest;
            break;

        case "green":
        case "b":
            chest = GameManager.Instance.RewardManager.B_Chest;
            break;

        case "red":
        case "a":
            chest = GameManager.Instance.RewardManager.A_Chest;
            break;

        case "black":
        case "s":
            chest = GameManager.Instance.RewardManager.S_Chest;
            break;

        case "rainbow":
        case "r":
            chest = GameManager.Instance.RewardManager.Rainbow_Chest;
            break;

        case "glitched":
        case "g":
            chest    = GameManager.Instance.RewardManager.B_Chest;
            glitched = true;
            break;

        default:
            Log("Chest type " + args[0] + " doesn't exist! Valid types: brown, blue, green, red, black, rainbow");
            return;
        }
        WeightedGameObject wGameObject = new WeightedGameObject();

        wGameObject.rawGameObject = chest.gameObject;
        WeightedGameObjectCollection wGameObjectCollection = new WeightedGameObjectCollection();

        wGameObjectCollection.Add(wGameObject);
        int   count           = 1;
        float origMimicChance = chest.overrideMimicChance;

        chest.overrideMimicChance = 0f;
        if (args.Length > 1)
        {
            bool success = int.TryParse(args[1], out count);
            if (!success)
            {
                Log("Second argument must be an integer (number)");
                return;
            }
        }
        for (int i = 0; i < count; i++)
        {
            Chest spawnedChest = currentRoom.SpawnRoomRewardChest(wGameObjectCollection, currentRoom.GetBestRewardLocation(new IntVector2(2, 1), Dungeonator.RoomHandler.RewardLocationStyle.PlayerCenter, true));
            spawnedChest.ForceUnlock();
            if (glitched)
            {
                spawnedChest.BecomeGlitchChest();
            }
        }
        chest.overrideMimicChance = origMimicChance;
    }