Пример #1
0
        public Assets(string folder, XElement xml)
        {
            XML = xml;
            if (XML.Element("VSwap") != null)
            {
                VSwap = VSwap.Load(folder, XML);
            }
            if (XML.Element("Maps") != null)
            {
                Maps = GameMap.Load(folder, XML);
            }
            if (XML.Element("VgaGraph") != null)
            {
                VgaGraph = VgaGraph.Load(folder, XML);
            }

            Pushwall = (ushort)(uint)XML?.Element("VSwap")?.Element("Objects")?.Element("Pushwall")?.Attribute("Number");

            // Creating floor texture
            uint[]            palette  = WarpWriterFriendlyPalette(VSwap.Palette);
            ByteArrayRenderer renderer = new ByteArrayRenderer()
            {
                Width  = 254,
                Height = 128,
                Color  = new FlatVoxelColor()
                {
                    Palette = palette,
                },
            };

            renderer.IsoTile(64, 64,
                             palette[
                                 WarpWriterFriendly(
                                     (byte)(int)XML.Element("Maps").Attribute("FloorIndex")
                                     )
                             ]
                             );
            Godot.Image image = new Image();
            image.CreateFromData((int)renderer.Width, (int)renderer.Height, false, Image.Format.Rgba8, renderer.Bytes);
            Floor = new ImageTexture();
            Floor.CreateFromImage(image, 0);

            FloorTileSet = new TileSet();
            FloorTileSet.CreateTile(0);
            FloorTileSet.TileSetTexture(0, Floor);
        }
Пример #2
0
        public VSwap(uint[] palette, Stream stream, ushort tileSqrt = 64)
        {
            Palette = palette;
            if (Palette == null)
            {
                throw new InvalidDataException("Must load a palette before loading a VSWAP!");
            }
            using (BinaryReader binaryReader = new BinaryReader(stream))
            {
                // parse header info
                NumPages   = binaryReader.ReadUInt16();
                SpritePage = binaryReader.ReadUInt16();
                Pages      = new byte[binaryReader.ReadUInt16()][]; // SoundPage
                Indexes    = new byte[Pages.Length][];

                uint[] pageOffsets = new uint[NumPages];
                uint   dataStart   = 0;
                for (ushort i = 0; i < pageOffsets.Length; i++)
                {
                    pageOffsets[i] = binaryReader.ReadUInt32();
                    if (i == 0)
                    {
                        dataStart = pageOffsets[0];
                    }
                    if ((pageOffsets[i] != 0 && pageOffsets[i] < dataStart) || pageOffsets[i] > stream.Length)
                    {
                        throw new InvalidDataException("VSWAP contains invalid page offsets.");
                    }
                }
                ushort[] pageLengths = new ushort[NumPages];
                for (ushort i = 0; i < pageLengths.Length; i++)
                {
                    pageLengths[i] = binaryReader.ReadUInt16();
                }

                ushort page;
                // read in walls
                for (page = 0; page < SpritePage; page++)
                {
                    if (pageOffsets[page] > 0)
                    {
                        binaryReader.BaseStream.Seek(pageOffsets[page], 0);
                        Indexes[page] = new byte[tileSqrt * tileSqrt];
                        for (ushort col = 0; col < tileSqrt; col++)
                        {
                            for (ushort row = 0; row < tileSqrt; row++)
                            {
                                Indexes[page][tileSqrt * row + col] = (byte)binaryReader.ReadByte();
                            }
                        }
                        Pages[page] = Index2ByteArray(Indexes[page], palette);
                    }
                }

                // read in sprites
                for (; page < Pages.Length; page++)
                {
                    if (pageOffsets[page] > 0)
                    {
                        binaryReader.BaseStream.Seek(pageOffsets[page], 0);
                        ushort leftExtent = binaryReader.ReadUInt16(),
                               rightExtent = binaryReader.ReadUInt16(),
                               startY, endY;
                        Indexes[page] = new byte[tileSqrt * tileSqrt];
                        for (ushort i = 0; i < Indexes[page].Length; i++)
                        {
                            Indexes[page][i] = 255; // set transparent
                        }
                        long[] columnDataOffsets = new long[rightExtent - leftExtent + 1];
                        for (ushort i = 0; i < columnDataOffsets.Length; i++)
                        {
                            columnDataOffsets[i] = pageOffsets[page] + binaryReader.ReadUInt16();
                        }
                        long trexels = stream.Position;
                        for (ushort column = 0; column <= rightExtent - leftExtent; column++)
                        {
                            long commands = columnDataOffsets[column];
                            binaryReader.BaseStream.Seek(commands, 0);
                            while ((endY = binaryReader.ReadUInt16()) != 0)
                            {
                                endY >>= 1;
                                binaryReader.ReadUInt16(); // Not using this value for anything. Don't know why it's here!
                                startY   = binaryReader.ReadUInt16();
                                startY >>= 1;
                                commands = stream.Position;
                                binaryReader.BaseStream.Seek(trexels, 0);
                                for (ushort row = startY; row < endY; row++)
                                {
                                    Indexes[page][(row * tileSqrt - 1) + column + leftExtent - 1] = binaryReader.ReadByte();
                                }
                                trexels = stream.Position;
                                binaryReader.BaseStream.Seek(commands, 0);
                            }
                        }
                        Pages[page] = Index2ByteArray(Indexes[page], palette);
                    }
                }

                // read in digisounds
                byte[] soundData = new byte[stream.Length - pageOffsets[Pages.Length]];
                binaryReader.BaseStream.Seek(pageOffsets[Pages.Length], 0);
                binaryReader.BaseStream.Read(soundData, 0, soundData.Length);

                uint       start = pageOffsets[NumPages - 1] - pageOffsets[Pages.Length];
                ushort[][] soundTable;
                using (MemoryStream memoryStream = new MemoryStream(soundData, (int)start, soundData.Length - (int)start))
                    soundTable = VgaGraph.Load16BitPairs(memoryStream);

                uint numDigiSounds = 0;
                while (numDigiSounds < soundTable.Length && soundTable[numDigiSounds][1] > 0)
                {
                    numDigiSounds++;
                }

                DigiSounds = new byte[numDigiSounds][];
                for (uint sound = 0; sound < DigiSounds.Length; sound++)
                {
                    if (soundTable[sound][1] > 0 && pageOffsets[Pages.Length + soundTable[sound][0]] > 0)
                    {
                        DigiSounds[sound] = new byte[soundTable[sound][1]];
                        start             = pageOffsets[Pages.Length + soundTable[sound][0]] - pageOffsets[Pages.Length];
                        for (uint bite = 0; bite < DigiSounds[sound].Length; bite++)
                        {
                            DigiSounds[sound][bite] = (byte)(soundData[start + bite] - 128); // Godot makes some kind of oddball conversion from the unsigned byte to a signed byte
                        }
                    }
                }
            }
        }