Inheritance: MonoBehaviour
Exemple #1
0
    public override void Spawn(List <Vector2Int> region, LevelGenerator levelGenerator)
    {
        int   spikeNum  = 0;
        bool  uniform   = (Random.Range(0, 2) == 0);
        float direction = (Random.Range(0, 2) == 0 ? 1 : -1);

        // Generate the trap, making sure we're not generating out of turn
        for (int posIdx = 0; posIdx < region.Count; ++posIdx)
        {
            Vector2Int pos = region[posIdx];

            if (levelGenerator.collisionMap.SpaceMarking(pos.x, pos.y) == 0)
            {
                GameObject trapObj = levelGenerator.PlaceMapPrefab("SpikeTrap", pos.x, pos.y);
                SpikeTrap  spikes  = trapObj.GetComponent <SpikeTrap>();
                levelGenerator.ClearFloorDecorations(pos);

                if (!uniform)
                {
                    spikes.timeOffset = 0.25f * spikeNum * direction;
                }

                ++spikeNum;
            }
        }
    }
Exemple #2
0
 void Awake()
 {
     // subscribe to events from within the TorchEvent
     torchEvent = GetComponent <TorchEvent>();
     spikeTrap  = GetComponent <SpikeTrap>();
     torchEvent.onSignalEnabledEvent  += EnableSpike;
     torchEvent.onSignalDisabledEvent += DisableSpike;
 }
Exemple #3
0
        public virtual void SpawnTrap()
        {
            Map map = this.Map;

            if (map == null)
            {
                return;
            }

            BaseTrap trap = null;

            int random = Utility.Random(100);

            if (22 > random)
            {
                trap = new SawTrap(Utility.RandomBool() ? SawTrapType.WestFloor : SawTrapType.NorthFloor);
            }
            else if (44 > random)
            {
                trap = new SpikeTrap(Utility.RandomBool() ? SpikeTrapType.WestFloor : SpikeTrapType.NorthFloor);
            }
            else if (66 > random)
            {
                trap = new GasTrap(Utility.RandomBool() ? GasTrapType.NorthWall : GasTrapType.WestWall);
            }
            else if (88 > random)
            {
                trap = new FireColumnTrap();
            }
            else
            {
                trap = new MushroomTrap();
            }

            if (trap == null)
            {
                return;
            }

            if (trap is FireColumnTrap || trap is MushroomTrap)
            {
                trap.Hue = 0x451;
            }

            // try 10 times to find a valid location
            for (int i = 0; i < 10; ++i)
            {
                int x = Utility.Random(this.m_RegionBounds.X, this.m_RegionBounds.Width);
                int y = Utility.Random(this.m_RegionBounds.Y, this.m_RegionBounds.Height);
                int z = this.Z;

                if (!map.CanFit(x, y, z, 16, false, false))
                {
                    z = map.GetAverageZ(x, y);
                }

                if (!map.CanFit(x, y, z, 16, false, false))
                {
                    continue;
                }

                trap.MoveToWorld(new Point3D(x, y, z), map);
                this.m_Traps.Add(trap);

                return;
            }

            trap.Delete();
        }
        public virtual void SpawnTraps(Field Handeling)
        {
            if (Handeling.AllowTraps == false)
            {
                return;
            }

            int  numberOfTraps = Handeling.NumberOfTraps;
            int  kindOfTrap    = 0;
            Item trap          = null;

            int randomValueX = 0;
            int randomValueY = 0;
            int negative     = 0;

            for (int i = 0; i < numberOfTraps; i++)
            {
                kindOfTrap = Utility.Random(5);

                randomValueX = Utility.Random(20);
                negative     = Utility.Random(2);
                if (negative > 0)
                {
                    randomValueX *= -1;
                }

                negative     = Utility.Random(2);
                randomValueY = Utility.Random(20);
                if (negative > 0)
                {
                    randomValueY *= -1;
                }

                switch (kindOfTrap)
                {
                case 0:
                {
                    trap = new FireColumnTrap();
                    break;
                }

                case 1:
                {
                    trap = new GasTrap();
                    break;
                }

                case 2:
                {
                    trap = new GiantSpikeTrap();
                    break;
                }

                case 3:
                {
                    trap = new SawTrap();
                    break;
                }

                case 4:
                {
                    trap = new SpikeTrap();
                    break;
                }
                }
                trap.Movable  = false;
                trap.Location = new Point3D((spawnpoint.X + randomValueX), (spawnpoint.Y + randomValueY), (spawnpoint.Z));
                trap.Map      = spawnmap;
                Traps.Add(trap);
            }
        }
        private static void SpawnFromString(IRoom room, SpriteBatch spriteBatch, string spawnType, int offsetX, int offsetY, int gridX, int gridY)
        {
            int         posX     = offsetX + gridX * RoomConstants.TileLength;
            int         posY     = offsetY + gridY * RoomConstants.TileLength;
            Point       position = new Point(posX, posY);
            IBlock      blockType;
            INpc        npcType;
            IItem       itemType;
            IBackground backgroundType;

            switch (spawnType)
            {
            //Blocks
            case RoomConstants.Block:
                blockType = new Square(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.BrickTile:
                blockType = new BrickTile(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.GapTile:
                blockType = new GapTile(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.Fire:
                position.X += RoomConstants.TileLength / 2;
                blockType   = new Fire(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.LadderTile:
                backgroundType = new LadderTile(spriteBatch, position);
                room.AllObjects.Spawn(backgroundType);
                break;

            case RoomConstants.Stairs:
                blockType = new Stairs(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.FishStatue:
                blockType = new FishStatues(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.DragonStatue:
                blockType = new DragonStatues(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.BlueGrass:
                backgroundType = new TileBlueGrass(spriteBatch, position);
                room.AllObjects.Spawn(backgroundType);
                break;

            case RoomConstants.Water:
                blockType = new TileWater(spriteBatch, position);
                room.AllObjects.Spawn(blockType);
                break;

            case RoomConstants.MovableBlock:
                blockType = new MovableSquare(spriteBatch, position);
                ((RoomWithMovableSquare)room).AddMovableSquare((MovableSquare)blockType);
                room.AllObjects.Spawn(blockType);
                break;

            //Npcs
            case RoomConstants.Aquamentus:
                position.Y += RoomConstants.TileLength / 2;
                npcType     = new Aquamentus(spriteBatch, position, room.AllObjects);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.Bat:
                npcType = new Bat(spriteBatch, position);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.Goriya:
                npcType = new Goriya(spriteBatch, position, room.AllObjects);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.Hand:
                npcType = new Hand(spriteBatch, position, ((RoomWallMaster)room).GetWallMasterRoomToJumpTo());
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.Jelly:
                npcType = new Jelly(spriteBatch, position);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.OldMan:
                position.X += RoomConstants.TileLength / 2;
                npcType     = new OldMan(spriteBatch, position);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.Skeleton:
                npcType = new Skeleton(spriteBatch, position);
                room.AllObjects.Spawn(npcType);
                break;

            case RoomConstants.SpikeTrap:
                npcType = new SpikeTrap(spriteBatch, position, room.AllObjects.GetPlayer(0));
                room.AllObjects.Spawn(npcType);
                break;

            //Items
            case RoomConstants.Compass:
                itemType = new CompassItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.Heart:
                position.X += (int)(4 * RoomConstants.SpriteMultiplier);
                position.Y += (int)(4 * RoomConstants.SpriteMultiplier);
                itemType    = new HeartItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.Key:
                itemType = new KeyItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.Map:
                itemType = new MapItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.Triforce:
                position.X += (int)(12 * RoomConstants.SpriteMultiplier);
                position.Y += (int)(2 * RoomConstants.SpriteMultiplier);
                itemType    = new TriforceItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.HeartContainer:
                itemType = new HeartContainerItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            case RoomConstants.Bow:
                itemType = new BowItem(spriteBatch, position);
                room.AllObjects.Spawn(itemType);
                break;

            default:
                break;
            }
        }
Exemple #6
0
    /// <summary>
    /// Loads things that aren't tiles at their correct positions
    /// </summary>
    /// <param name="positionStringList">The given list of strings by the main method</param>
    protected void LevelPositionLoader(List <string> positionStringList)
    {
        for (int i = 0; i < positionStringList.Count; i++)
        {
            string[] splitArray = positionStringList[i].Split(' ');
            // All the code blocks below check what object needs to be loaded, loads them in, and then assigns the correct values that are in the file to them
            switch (splitArray[0])
            {
            case "PENGUIN":
                Monster penguin = new LittlePenguin(this)
                {
                    StartPosition = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]))
                };
                penguin.Reset();
                monsterList.Add(penguin);
                break;

            case "DUMMY":
                Monster dummy = new Dummy("Assets/Sprites/Enemies/Dummy", this)
                {
                    StartPosition = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]))
                };
                dummy.Reset();
                monsterList.Add(dummy);
                break;

            case "BUNNY":
                Bunny bunny = new Bunny(this)
                {
                    StartPosition = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]))
                };
                bunny.Reset();
                monsterList.Add(bunny);
                break;

            case "SPIKETRAP":
                AutomatedObject spikeTrap = new SpikeTrap("Assets/Sprites/InteractiveObjects/SpikeTrap@2", "spikeTrap", 0, this);
                spikeTrap.Position = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]));
                objectList.Add(spikeTrap);
                break;

            case "HANDLE":
                Handle handle = new Handle("Assets/Sprites/InteractiveObjects/handles@2", "Handle", 0)
                {
                    Position = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]))
                };
                handle.ObjectNumberConnected = int.Parse(splitArray[3]);
                objectList.Add(handle);
                break;

            case "TRAPDOOR":
                Trapdoor trapdoor = new Trapdoor(TileType.DoorTile, "Assets/Sprites/InteractiveObjects/NextLevelCombined@2", "Trapdoor", 0, this)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2])),
                    Objectnumber = int.Parse(splitArray[3])
                };
                objectList.Add(trapdoor);
                break;

            case "DOOR":
                Door doorupperleft = new Door("Assets/Sprites/Tiles/DoorBottomRight@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]) + 50, float.Parse(splitArray[2]) + 50),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door doorupperright = new Door("Assets/Sprites/Tiles/DoorUpperRight@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]) + 50, float.Parse(splitArray[2])),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door doorbottomleft = new Door("Assets/Sprites/Tiles/DoorBottomLeft@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]) + 50),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door doorbottomright = new Door("Assets/Sprites/Tiles/DoorUpperleft@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2])),
                    Objectnumber = int.Parse(splitArray[3])
                };
                levelTileField.Add(doorupperleft, (int)doorupperleft.Position.X / 50, (int)doorupperleft.Position.Y / 50);
                levelTileField.Add(doorupperright, (int)doorupperright.Position.X / 50, (int)doorupperright.Position.Y / 50);
                levelTileField.Add(doorbottomleft, (int)doorbottomleft.Position.X / 50, (int)doorbottomleft.Position.Y / 50);
                levelTileField.Add(doorbottomright, (int)doorbottomright.Position.X / 50, (int)doorbottomright.Position.Y / 50);
                break;

            case "VDOOR":
                Door vdoorupperleft = new Door("Assets/Sprites/Tiles/VerticalDoorUpperLeft@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2])),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door vdoorupperright = new Door("Assets/Sprites/Tiles/VerticalDoorUpperRight@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]) + 50, float.Parse(splitArray[2])),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door vdoormiddleleft = new Door("Assets/Sprites/Tiles/VerticalDoorMiddleLeft@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]) + 50),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door vdoorbottomleft = new Door("Assets/Sprites/Tiles/VerticalDoorBottomLeft@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]), float.Parse(splitArray[2]) + 100),
                    Objectnumber = int.Parse(splitArray[3])
                };
                Door vdoormiddleright = new Door("Assets/Sprites/Tiles/VerticalDoorMiddleRight@2", "Door", 0)
                {
                    Position     = new Vector2(float.Parse(splitArray[1]) + 50, float.Parse(splitArray[2]) + 50),
                    Objectnumber = int.Parse(splitArray[3])
                };
                levelTileField.Add(vdoorupperleft, (int)vdoorupperleft.Position.X / 50, (int)vdoorupperleft.Position.Y / 50);
                levelTileField.Add(vdoorupperright, (int)vdoorupperright.Position.X / 50, (int)vdoorupperright.Position.Y / 50);
                levelTileField.Add(vdoorbottomleft, (int)vdoorbottomleft.Position.X / 50, (int)vdoorbottomleft.Position.Y / 50);
                levelTileField.Add(vdoormiddleright, (int)vdoormiddleright.Position.X / 50, (int)vdoormiddleright.Position.Y / 50);
                levelTileField.Add(vdoormiddleleft, (int)vdoormiddleleft.Position.X / 50, (int)vdoormiddleleft.Position.Y / 50);
                break;

            case "SHIELDMAIDEN":
                ShieldMaidenLoader(splitArray);
                break;

            case "KEY":
                KeyLoader(splitArray);
                break;

            case "LOCK":
                LockLoader(splitArray);
                break;
            }
        }
    }
Exemple #7
0
    void Start()
    {
        //anim.Play("TestAnim");
        // anim["TestAnim"].speed = 0;
        // anim["TestAnim"].wrapMode = WrapMode.Loop;



        for (int i = 0; i < actorAnimation.Length; i++)
        {
            actorAnimation[i].Play("Walk");
            actorAnimation[i]["Walk"].speed     = 0;
            actorAnimation[i]["Walk"].wrapMode  = WrapMode.Loop;
            actorAnimation[i]["Walk"].blendMode = AnimationBlendMode.Blend;

            actorAnimation[i].Play("Jump");
            actorAnimation[i]["Jump"].speed     = 0;
            actorAnimation[i]["Jump"].wrapMode  = WrapMode.Loop;
            actorAnimation[i]["Jump"].blendMode = AnimationBlendMode.Blend;

            actorAnimation[i].Play("Idle");
            actorAnimation[i]["Idle"].speed     = 0;
            actorAnimation[i]["Idle"].wrapMode  = WrapMode.Loop;
            actorAnimation[i]["Idle"].blendMode = AnimationBlendMode.Blend;

            actorAnimation[i].Play("Falling");
            actorAnimation[i]["Falling"].speed     = 0;
            actorAnimation[i]["Falling"].wrapMode  = WrapMode.Loop;
            actorAnimation[i]["Falling"].blendMode = AnimationBlendMode.Blend;

            actorAnimation[i].Play("Death");
            actorAnimation[i]["Death"].speed = 0;
            //actorAnimation[i]["Death"].wrapMode = WrapMode.Loop;
            actorAnimation[i]["Death"].blendMode = AnimationBlendMode.Blend;
        }

        timeline = new Timeline();

        timeline.layerMask = ~LayerMask.GetMask("Platform");



        //
        Actor[] actor = new Actor[agent.Length];
        for (int i = 0; i < actor.Length; i++)
        {
            actor[i] = new Actor(agent[i].transform.position);
        }
        //
        MovableObject[] movableObject = new MovableObject[movableObjects.Length];
        for (int i = 0; i < movableObject.Length; i++)
        {
            RaycastHit hit;
            Physics.Raycast(movableObjects[i].transform.position, Vector3.down, out hit);
            movableObject[i] = new MovableObject(movableObjects[i].transform.position, hit.point, 10, 0, 0);
        }
        //
        DartWall[] dartWalls = new DartWall[dartwallObjects.Length];
        for (int i = 0; i < dartWalls.Length; i++)
        {
            dartWalls[i] = new DartWall(dartwallObjects[i].transform.position, dartwallObjects[i].transform.localScale, dartwallObjects[i].transform.rotation, new PressurePlate(dartwallObjects[i].transform.GetChild(0).transform.position, dartwallObjects[i].transform.GetChild(0).transform.localScale));
        }
        //
        Zipline[] ziplines = new Zipline[ziplineObjects.Length];
        for (int i = 0; i < ziplines.Length; i++)
        {
            Vector3[] point = new Vector3[2];
            point[0]    = ziplineObjects[i].transform.position;
            point[1]    = ziplineObjects[i].transform.GetChild(0).transform.position;
            ziplines[i] = new Zipline(point);
        }
        //
        SpikeTrap[] spikeTrap = new SpikeTrap[spikeObjects.Length];
        for (int i = 0; i < spikeTrap.Length; i++)
        {
            if (spikeObjects[i] != null)
            {
                Vector3[] STpoint = new Vector3[2];
                STpoint[0]   = spikeObjects[i].transform.GetChild(1).transform.position;
                STpoint[1]   = STpoint[0] + new Vector3(0, 2.75f, 0);
                spikeTrap[i] = new SpikeTrap(STpoint, STpoint[0], spikeObjects[i].transform.localScale, new PressurePlate(spikeObjects[i].transform.GetChild(0).transform.position, spikeObjects[i].transform.GetChild(0).transform.localScale));
            }
        }
        //
        UnstableFloor[] unstableFloors = new UnstableFloor[unstableFloorObjects.Length];
        for (int i = 0; i < unstableFloors.Length; i++)
        {
            Vector3[] UFpoint = new Vector3[2];
            UFpoint[0]        = unstableFloorObjects[i].transform.position;
            UFpoint[1]        = UFpoint[0] + Vector3.down * 25;
            unstableFloors[i] = new UnstableFloor(UFpoint[0], unstableFloorObjects[i].transform.localScale, UFpoint);
        }
        //
        MovingPlatformSet[] movingPlatformSet = new MovingPlatformSet[movingPlatformSetObjects.Length];
        for (int i = 0; i < movingPlatformSet.Length; i++)
        {
            int platforms          = 0;
            int pressurePlateChild = 0;
            int a = 0;
            foreach (Transform child in movingPlatformSetObjects[i].transform)
            {
                if (child.transform.tag == "Platform")
                {
                    platforms++;
                }
                else
                {
                    pressurePlateChild = a;
                }
                a++;
            }

            MovingPlatform[] movingPlatforms = new MovingPlatform[platforms];
            for (int j = 0; j < platforms; j++)
            {
                Vector3[] point = new Vector3[2];
                point[0]           = movingPlatformSetObjects[i].transform.GetChild(j).transform.position;
                point[1]           = point[0] + movingPlatformSetObjects[i].transform.GetChild(j).transform.forward * 4;
                movingPlatforms[j] = new MovingPlatform(point[0], movingPlatformSetObjects[i].transform.GetChild(j).transform.localScale, point);
            }

            movingPlatformSet[i] = new MovingPlatformSet(movingPlatforms, new PressurePlate(movingPlatformSetObjects[i].transform.GetChild(pressurePlateChild).transform.position, movingPlatformSetObjects[i].transform.GetChild(pressurePlateChild).transform.localScale));

            //movingPlatformSet[i].movingPlatforms = new MovingPlatform[movingPlatformSetObjects[i].transform.childCount];
        }
        //
        EndArea[] endAreas = new EndArea[endAreaObjects.Length];
        for (int i = 0; i < endAreas.Length; i++)
        {
            endAreas[i] = new EndArea(endAreaObjects[i].transform.position, endAreaObjects[i].transform.localScale);
        }

        timeline.Init(timelineSlider.maxValue, actor, movableObject, dartWalls, ziplines, spikeTrap, unstableFloors, movingPlatformSet, endAreas);
        //Timeline.RotateTowardsObject(timeline, timeline.turret[0], timeline.actor[0], 3);
        UpdateTimelineParts();

        SetTimelineCurrentValue(0);
    }
Exemple #8
0
 public void AddSpike(SpikeTrap spike)
 {
     SpikeList.Add(spike);
 }
Exemple #9
0
        public override void OnResponse(NetState sender, RelayInfo info)
        {
            Mobile from = sender.Mobile;

            switch (info.ButtonID)
            {
            case 1:
            {
                FireColumnTrap sTrap = new FireColumnTrap();
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 2:
            {
                FlameSpurtTrap sTrap = new FlameSpurtTrap();
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 3:
            {
                GiantSpikeTrap sTrap = new GiantSpikeTrap();
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 4:
            {
                GasTrap sTrap = new GasTrap(GasTrapType.Floor);
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 3)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 5:
            {
                MushroomTrap sTrap = new MushroomTrap();
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 6:
            {
                SpikeTrap sTrap = new SpikeTrap(SpikeTrapType.WestWall);
                sTrap.ItemID = 4360;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 5)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 7:
            {
                SpikeTrap sTrap = new SpikeTrap(SpikeTrapType.NorthWall);
                sTrap.ItemID = 4379;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 5)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 8:
            {
                SpikeTrap sTrap = new SpikeTrap(SpikeTrapType.WestFloor);
                sTrap.ItemID = 4506;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 9:
            {
                SpikeTrap sTrap = new SpikeTrap(SpikeTrapType.NorthFloor);
                sTrap.ItemID = 4512;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 10:
            {
                StoneFaceTrap sTrap = new StoneFaceTrap();
                sTrap.ItemID = 0x110F;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 3)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 11:
            {
                SawTrap sTrap = new SawTrap(SawTrapType.NorthWall);
                sTrap.ItemID = 0x1103;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 10)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 12:
            {
                SawTrap sTrap = new SawTrap(SawTrapType.WestWall);
                sTrap.ItemID = 0x1116;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 10)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 13:
            {
                SawTrap sTrap = new SawTrap(SawTrapType.WestFloor);
                sTrap.ItemID = 0x11B1;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 14:
            {
                SawTrap sTrap = new SawTrap(SawTrapType.NorthFloor);
                sTrap.ItemID = 0x11AC;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, from.Z), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }

            case 15:
            {
                StoneFaceTrap sTrap = new StoneFaceTrap();
                sTrap.ItemID = 0x10FC;
                sTrap.MoveToWorld(new Point3D(from.X, from.Y, (from.Z + 3)), from.Map);
                from.SendGump(new AddTrapGump());
                break;
            }
            }
        }