Esempio n. 1
0
        /// <summary>
        /// Expands currentLevelIndex room data and adds a door to CurrentScreen
        /// </summary>
        public DoorInstance AddDoor(DoorType type, DoorSide side)
        {
            var newDoor = DoorInstance.GetNew();

            newDoor.Side = side;
            newDoor.Type = type;
            _doors.Add(newDoor);

            return(newDoor);
        }
Esempio n. 2
0
 public RBStation(string name, string asound, string dsound)
 {
     this.stationname     = name;
     this.doorside        = DoorSide.N;
     this.system          = System.ATS;
     this.arrivalsound    = asound;
     this.departuresound  = dsound;
     this.passalarm       = 0;
     this.forcedredsignal = 0;
     this.change_ends     = false;
 }
Esempio n. 3
0
 /// <summary>Removes the specified door.</summary>
 public void DeleteDoor(DoorSide side)
 {
     // Seek through doors and delete any that are left-side.
     for (int i = 0; i < _doors.Count; i++)
     {
         var d = _doors[i];
         if (d.Side == side)
         {
             _doors.Remove(d);
             return;
         }
     }
 }
Esempio n. 4
0
        /// <summary>Specifies the door type for the right door.</summary>
        /// <param name="type"></param>
        /// <returns>The data object that was modified.</returns>
        public DoorInstance ChangeExistingDoor(DoorSide side, DoorType type)
        {
            for (int i = 0; i < _doors.Count; i++)
            {
                var d = _doors[i];
                if (d.Side == side)
                {
                    d.Type = type;
                    return(d);
                }
            }

            return(null);
        }
Esempio n. 5
0
        public ChangeDoor(EditroidUndoRedoQueue q, Screen screen, DoorSide side, DoorType type)
            : base(q, screen)
        {
            this.side    = side;
            this.newType = type;

            oldType = DoorType.Invalid;
            foreach (DoorInstance d in Screen.Doors)
            {
                if (d.Side == side)
                {
                    oldType = d.Type;
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Converts lettered door side values to numbered
        /// </summary>
        /// <param name="ds">The lettered door side value</param>
        /// <returns>The numbered door side value</returns>
        public int DoorSideToInt(DoorSide ds)
        {
            switch (ds)
            {
            case DoorSide.L:
                return(-1);

            case DoorSide.N:
                return(0);

            case DoorSide.R:
                return(1);

            case DoorSide.B:
                return(0);
            }
            return(0);
        }
Esempio n. 7
0
        private void DisassmItem(ItemSeeker seeker)
        {
            result.AppendLine();

            switch (seeker.ItemType)
            {
            case ItemTypeIndex.Nothing:
                throw new ItemDisassmException("Encountered an unexpected item type when disassembling an item.");

            case ItemTypeIndex.Enemy:
                // byte: Enemy code and sprite slot
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Enemy, sprite slot = " + seeker.SpriteSlot.ToString());
                // byte: hard flag (0x80), enemy type
                WriteLine(ByteDirective(seeker.SubTypeByte),
                          "Enemy type = " + seeker.EnemyTypeIndex + (seeker.EnemyIsHard ? ", hard enemy" : ""));
                // Byte: screen position
                WriteLine(ByteDirective(seeker.ScreenPosition.Value),
                          "Screen X = " + seeker.ScreenPosition.X.ToString() + "  Y = " + seeker.ScreenPosition.Y.ToString());
                break;

            case ItemTypeIndex.PowerUp:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Power Up");
                // byte: Item type
                WriteLine(ByteDirective(seeker.SubTypeByte),
                          "Type = " + seeker.PowerUpName);
                // Byte: screen position
                WriteLine(ByteDirective(seeker.ScreenPosition.Value),
                          "Screen X = " + seeker.ScreenPosition.X.ToString() + "  Y = " + seeker.ScreenPosition.Y.ToString());
                break;

            case ItemTypeIndex.Mella:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Mella");
                break;

            case ItemTypeIndex.Elevator:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Elevator");
                // byte: Item type
                WriteLine(ByteDirective(seeker.SubTypeByte),
                          "Type = " + seeker.Destination.ToString());
                break;

            case ItemTypeIndex.Turret:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Turret, type = " + seeker.SpriteSlot.ToString());
                // Byte: screen position
                WriteLine(ByteDirective(seeker.ScreenPosition.Value),
                          "Screen X = " + seeker.ScreenPosition.X.ToString() + "  Y = " + seeker.ScreenPosition.Y.ToString());
                break;

            case ItemTypeIndex.MotherBrain:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Mother Brain");
                break;

            case ItemTypeIndex.Zebetite:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Zebetite, index = " + seeker.SpriteSlot.ToString());
                break;

            case ItemTypeIndex.Rinkas:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Rinka " + seeker.SpriteSlot.ToString());
                break;

            case ItemTypeIndex.Door:
                // byte: Door
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Doop");
                // byte: Door type
                var      doorType = seeker.SubTypeByte;
                DoorSide side     = (DoorSide)(doorType & 0xF0);
                DoorType type     = (DoorType)(doorType & 0x0F);
                WriteLine(ByteDirective(seeker.SubTypeByte),
                          "Door: " + side.ToString() + " " + type.ToString());
                break;

            case ItemTypeIndex.PalSwap:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Palette Swap");
                break;

            case ItemTypeIndex.Unused_b:
            case ItemTypeIndex.Unused_c:
            case ItemTypeIndex.Unused_d:
            case ItemTypeIndex.Unused_e:
            case ItemTypeIndex.Unused_f:
                // byte: Item code
                WriteLine(ByteDirective(seeker.ItemTypeByte),
                          "Invalid Item Type!");
                break;

            default:
                throw new ItemDisassmException("Unexpected item type in DisassmItem");
                break;
            }
        }
Esempio n. 8
0
 public ChangeDoor ChangeDoor(DoorSide side, DoorType type)
 {
     return(new ChangeDoor(queue, CurrentScreen, side, type));
 }
Esempio n. 9
0
 public RBStation(string name, DoorSide ds, System sys, string asound, string dsound, int pa, int frs, bool ce)
 {
 }