コード例 #1
0
    public void Realize()
    {
        if (realizedObject != null)
        {
            return;
        }
        switch ((patch_AbstractPhysicalObject.AbstractObjectType)type)
        {
        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.Rock:
            realizedObject = new Rock(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.Spear:
            if (((this as AbstractPhysicalObject) as AbstractSpear).explosive)
            {
                realizedObject = new ExplosiveSpear(this, world);
            }
            else
            {
                realizedObject = new Spear(this, world);
            }
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.FlareBomb:
            realizedObject = new FlareBomb(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.VultureMask:
            realizedObject = new VultureMask(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.PuffBall:
            realizedObject = new PuffBall(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.DangleFruit:
            realizedObject = new DangleFruit(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.PebblesPearl:
            realizedObject = new PebblesPearl(this, world);
            break;

        //case (patch_AbstractPhysicalObject.AbstractObjectType)patch_AbstractPhysicalObject.AbstractObjectType.MoonPearl:
        //    this.realizedObject = new MoonPearl(this, this.world);
        //    break;
        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.SLOracleSwarmer:
            realizedObject = new SLOracleSwarmer(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.SSOracleSwarmer:
            realizedObject = new SSOracleSwarmer(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractObjectType.LMOracleSwarmer:
            realizedObject = new LMOracleSwarmer(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.DataPearl:
            realizedObject = new DataPearl(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.SeedCob:
            realizedObject = new SeedCob(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.WaterNut:
            if (((this as AbstractPhysicalObject) as WaterNut.AbstractWaterNut).swollen)
            {
                realizedObject = new SwollenWaterNut(this);
            }
            else
            {
                realizedObject = new WaterNut(this);
            }
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.JellyFish:
            realizedObject = new JellyFish(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.Lantern:
            realizedObject = new Lantern(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.KarmaFlower:
            realizedObject = new KarmaFlower(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.Mushroom:
            realizedObject = new Mushroom(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.VoidSpawn:
            realizedObject = new VoidSpawn(this, (Room.realizedRoom == null) ? 0f : Room.realizedRoom.roomSettings.GetEffectAmount(RoomSettings.RoomEffect.Type.VoidMelt), Room.realizedRoom != null && VoidSpawnKeeper.DayLightMode(Room.realizedRoom));
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.FirecrackerPlant:
            realizedObject = new FirecrackerPlant(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)(patch_AbstractPhysicalObject.AbstractObjectType) AbstractPhysicalObject.AbstractObjectType.SlimeMold:
            realizedObject = new SlimeMold(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.FlyLure:
            realizedObject = new FlyLure(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.ScavengerBomb:
            realizedObject = new ScavengerBomb(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.SporePlant:
            realizedObject = new SporePlant(this, world);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.EggBugEgg:
            realizedObject = new EggBugEgg(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.NeedleEgg:
            realizedObject = new NeedleEgg(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.DartMaggot:
            realizedObject = new DartMaggot(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.BubbleGrass:
            realizedObject = new BubbleGrass(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.NSHSwarmer:
            realizedObject = new NSHSwarmer(this);
            break;

        case (patch_AbstractPhysicalObject.AbstractObjectType)AbstractPhysicalObject.AbstractObjectType.OverseerCarcass:
            realizedObject = new OverseerCarcass(this, world);
            break;

        case AbstractObjectType.SmallPiston:
            realizedObject = new SmallPiston(this);
            break;

        case AbstractObjectType.LargePiston:
            realizedObject = new LargePiston(this);
            break;

        case AbstractObjectType.GiantPiston:
            realizedObject = new GiantPiston(this);
            break;
        }
        for (int i = 0; i < stuckObjects.Count; i++)
        {
            if (stuckObjects[i].A.realizedObject == null && stuckObjects[i].A != this)
            {
                stuckObjects[i].A.Realize();
            }
            if (stuckObjects[i].B.realizedObject == null && stuckObjects[i].B != this)
            {
                stuckObjects[i].B.Realize();
            }
        }
    }
コード例 #2
0
        public void OriginalRealize()
        {
            try {
                if (this.realizedObject != null)
                {
                    return;
                }
            } catch (Exception e) {
                Debug.LogError("Failed On Realize Object Check");
            }


            try {
                switch (this.type)
                {
                case AbstractPhysicalObject.AbstractObjectType.Rock:
                    this.realizedObject = new Rock(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.Spear:
                    if ((this as AbstractPhysicalObject as AbstractSpear).explosive)
                    {
                        this.realizedObject = new ExplosiveSpear(this, this.world);
                    }
                    else
                    {
                        this.realizedObject = new Spear(this, this.world);
                    }
                    break;

                case AbstractPhysicalObject.AbstractObjectType.FlareBomb:
                    this.realizedObject = new FlareBomb(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.VultureMask:
                    this.realizedObject = new VultureMask(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.PuffBall:
                    this.realizedObject = new PuffBall(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.DangleFruit:
                    this.realizedObject = new DangleFruit(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.PebblesPearl:
                    this.realizedObject = new PebblesPearl(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.SLOracleSwarmer:
                    this.realizedObject = new SLOracleSwarmer(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.SSOracleSwarmer:
                    this.realizedObject = new SSOracleSwarmer(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.DataPearl:
                    this.realizedObject = new DataPearl(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.SeedCob:
                    this.realizedObject = new SeedCob(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.WaterNut:
                    if ((this as AbstractPhysicalObject as WaterNut.AbstractWaterNut).swollen)
                    {
                        this.realizedObject = new SwollenWaterNut(this);
                    }
                    else
                    {
                        this.realizedObject = new WaterNut(this);
                    }
                    break;

                case AbstractPhysicalObject.AbstractObjectType.JellyFish:
                    this.realizedObject = new JellyFish(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.Lantern:
                    this.realizedObject = new Lantern(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.KarmaFlower:
                    this.realizedObject = new KarmaFlower(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.Mushroom:
                    this.realizedObject = new Mushroom(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.VoidSpawn:
                    this.realizedObject = new VoidSpawn(this, (base.Room.realizedRoom == null) ? 0f : base.Room.realizedRoom.roomSettings.GetEffectAmount(RoomSettings.RoomEffect.Type.VoidMelt), base.Room.realizedRoom != null && VoidSpawnKeeper.DayLightMode(base.Room.realizedRoom));
                    break;

                case AbstractPhysicalObject.AbstractObjectType.FirecrackerPlant:
                    this.realizedObject = new FirecrackerPlant(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.SlimeMold:
                    this.realizedObject = new SlimeMold(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.FlyLure:
                    this.realizedObject = new FlyLure(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.ScavengerBomb:
                    this.realizedObject = new ScavengerBomb(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.SporePlant:
                    this.realizedObject = new SporePlant(this, this.world);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.EggBugEgg:
                    this.realizedObject = new EggBugEgg(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.NeedleEgg:
                    this.realizedObject = new NeedleEgg(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.DartMaggot:
                    this.realizedObject = new DartMaggot(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.BubbleGrass:
                    this.realizedObject = new BubbleGrass(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.NSHSwarmer:
                    this.realizedObject = new NSHSwarmer(this);
                    break;

                case AbstractPhysicalObject.AbstractObjectType.OverseerCarcass:
                    this.realizedObject = new OverseerCarcass(this, this.world);
                    break;
                }
            } catch (Exception e) {
                Debug.LogError(string.Format("Failed on realized object creation, world is {0}, type is {1}, and this is {2}", world, type, this));
            }

            try {
                for (int i = 0; i < this.stuckObjects.Count; i++)
                {
                    if (this.stuckObjects[i].A.realizedObject == null && this.stuckObjects[i].A != this)
                    {
                        this.stuckObjects[i].A.Realize();
                    }
                    if (this.stuckObjects[i].B.realizedObject == null && this.stuckObjects[i].B != this)
                    {
                        this.stuckObjects[i].B.Realize();
                    }
                }
            } catch (Exception e) {
                Debug.LogError("Failed on Stuck Realization");
            }
        }