Alexandria.Engines.Sciagi.Resources.PictureInstruction.ReadInstruction C# (CSharp) Метод

        public static PictureInstruction ReadInstruction(Stream stream, ref PicturePatternFlags patternFlags, ref byte patternNumber)
        {
            PictureOpcode opcode = (PictureOpcode)ReadByte(stream);

            switch (opcode) {
                case PictureOpcode.SetColor: return new SetColor(stream);
                case PictureOpcode.DisableVisual: return new DisableVisual();
                case PictureOpcode.SetPriority: return new SetPriority(stream);
                case PictureOpcode.DisablePriority: return new DisablePriority();
                case PictureOpcode.DrawFloodfill: return new DrawFloodfill(stream);
                case PictureOpcode.SetPatternFlags: return new SetPatternFlags(stream, ref patternFlags);
                case PictureOpcode.SetControl: return new SetControl(stream);
                case PictureOpcode.DisableControl: return new DisableControl();

                case PictureOpcode.DrawRelativeMediumLines:
                case PictureOpcode.DrawRelativeLongLines:
                case PictureOpcode.DrawRelativeShortLines: return new DrawLines(opcode, stream);

                case PictureOpcode.DrawRelativeMediumPatterns:
                case PictureOpcode.DrawRelativePatterns:
                case PictureOpcode.DrawAbsolutePatterns: return new DrawPatterns(opcode, stream, patternFlags, ref patternNumber);

                case PictureOpcode.ExtendedOpcode:
                    var extendedOpcode = (PictureExtendedOpcode)ReadByte(stream);
                    switch (extendedOpcode) {
                        case PictureExtendedOpcode.SetPaletteEntry:
                        case PictureExtendedOpcode.SetPalette: return new SetPalette(stream, extendedOpcode);

                        case PictureExtendedOpcode.Mono0: return new Mono0(stream);
                        case PictureExtendedOpcode.Mono1:
                        case PictureExtendedOpcode.Mono2:
                        case PictureExtendedOpcode.Mono3: return new Mono123(stream, extendedOpcode);

                        default: throw new Exception(String.Format("Unknown extended opcode 0x{0:X2} ({1})", (int)opcode, opcode));
                    }

                case PictureOpcode.Quit: return new Quit();
                default: throw new Exception(String.Format("Unknown opcode 0x{0:X2} ({1}).", (int)opcode, opcode));
            }
        }

        internal Picture(AssetLoader loader)
            : base(loader)
        {
            BinaryReader reader = loader.Reader;
            ushort       check  = reader.ReadUInt16();
            Codex <PictureInstruction> instructions = new Codex <PictureInstruction>();
            Codex <PictureCel>         cels         = new Codex <PictureCel>();

            if (check == 0x0E)               // VGA picture
            {
                int celCount = reader.ReadUInt16();
                Unknowns.ReadInt16s(reader, 1);                 // 0x2A
                int paletteOffset = reader.ReadInt32();
                Dimensions = new Vector2i(reader.ReadUInt16(), reader.ReadUInt16());

                reader.BaseStream.Position = paletteOffset;
                Palette = new Palette(loader);
                AddChild(Palette);

                for (int celIndex = 0; celIndex < celCount; celIndex++)
                {
                    PictureCel cel = new PictureCel(this, celIndex, loader);

                    cels.Add(cel);
                    AddChild(cel);
                    instructions.Add(new PictureInstruction.DrawCel(cel));
                }
            }
            else
            {
                Dimensions = new Vector2i(320, 190);
                reader.BaseStream.Seek(-2, SeekOrigin.Current);
                byte[] data   = reader.ReadBytes(checked ((int)reader.BaseStream.Length));
                Stream stream = new MemoryStream(data, false);
                PicturePatternFlags patternFlags = PicturePatternFlags.None;
                byte patternNumber = 0;

                while (true)
                {
                    PictureInstruction instruction = PictureInstruction.ReadInstruction(stream, ref patternFlags, ref patternNumber);
                    instructions.Add(instruction);
                    if (instruction.IsQuit)
                    {
                        break;
                    }
                }
            }

            Cels         = cels;
            Instructions = instructions;
        }