Ejemplo n.º 1
0
        internal void Write(Writer writer)
        {
            writer.WriteRSDKString(GameName);
            writer.WriteRSDKString(GameSubname);

            this.WritePalettes(writer);
            this.WriteObjectsNames(writer);

            writer.Write((byte)Globals.Count);

            for (int i = 0; i < Globals.Count; i++)
            {
                Globals[i].Write(writer);
            }

            this.WriteWAVConfiguration(writer);

            Stages.Write(writer);
            writer.Write((byte)0);

            writer.Close();
        }
Ejemplo n.º 2
0
        internal void Write(Writer writer)
        {
            // Save width and height
            writer.Write(LayerCount);
            writer.Write((byte)Lines.Count);

            for (int i = 0; i < Lines.Count; i++)
            {
                Lines[i].Write(writer);
            }

            for (int i = 0; i < LayerCount; i++)
            {
                Layers[i].Write(writer);
            }

            for (int i = 0; i < Unknown.Count; i++)
            {
                writer.Write(Unknown[i]);
            }
            writer.Close();
        }
Ejemplo n.º 3
0
        public void write(Writer writer)
        {
            writer.Write(signature);

            int vertCount = frames.Count >= 0 ? frames[0].vertices.Count : 0;

            writer.Write((ushort)vertCount);

            for (int v = 0; v < vertCount; ++v)
            {
                writer.Write(textureUVs[v].u);
                writer.Write(textureUVs[v].v);
            }

            writer.Write((ushort)(indices.Count / 3));
            for (int i = 0; i < indices.Count; ++i)
            {
                writer.Write(indices[i]);
            }

            writer.Write((ushort)frames.Count);
            for (int f = 0; f < frames.Count; ++f)
            {
                for (int v = 0; v < vertCount; ++v)
                {
                    writer.Write(frames[f].vertices[v].x);
                    writer.Write(frames[f].vertices[v].y);
                    writer.Write(frames[f].vertices[v].z);

                    writer.Write(frames[f].vertices[v].nx);
                    writer.Write(frames[f].vertices[v].ny);
                    writer.Write(frames[f].vertices[v].nz);
                }
            }

            writer.Close();
        }
Ejemplo n.º 4
0
        public void write(Writer writer)
        {
            // Too Lazy to do this properly, have 8 layers no matter what
            writer.Write((byte)8);

            writer.Write((byte)hScroll.Count);
            foreach (ScrollInfo hScrollInfo in hScroll)
            {
                hScrollInfo.write(writer);
            }

            writer.Write((byte)vScroll.Count);
            foreach (ScrollInfo vScrollInfo in vScroll)
            {
                vScrollInfo.write(writer);
            }

            foreach (Layer layer in layers)
            {
                layer.write(writer);
            }

            writer.Close();
        }
Ejemplo n.º 5
0
        public void write(Writer writer)
        {
            // General
            writer.Write(loadGlobalObjects);

            // Palettes
            stagePalette.write(writer);

            // SoundFX
            writer.Write((byte)soundFX.Count);

            foreach (GameConfig.SoundInfo info in soundFX)
            {
                writer.writeRSDKString(info.name);
            }

            foreach (GameConfig.SoundInfo info in soundFX)
            {
                writer.writeRSDKString(info.path);
            }

            // Objects
            writer.Write((byte)objects.Count);

            foreach (GameConfig.ObjectInfo info in objects)
            {
                writer.writeRSDKString(info.name);
            }

            foreach (GameConfig.ObjectInfo info in objects)
            {
                writer.writeRSDKString(info.script);
            }

            writer.Close();
        }
Ejemplo n.º 6
0
        public void write(Writer writer, bool skipHeader = false, bool useLocal = false)
        {
            #region Header
            // [GIF HEADER]
            if (!skipHeader)
            {
                writer.Write("GIF".ToCharArray()); // File type
                writer.Write("89a".ToCharArray()); // File Version

                writer.Write(width);
                writer.Write(height);

                if (useLocal)
                {
                    writer.Write((byte)((1 << 7) | (6 << 4) | 6)); // 1 == hasColours, 6 == paletteSize of 128, 6 == 7bpp
                }
                else
                {
                    writer.Write((byte)((1 << 7) | (7 << 4) | 7)); // 1 == hasColours, 7 == paletteSize of 256, 7 == 8bpp
                }
                writer.Write((byte)0);
                writer.Write((byte)0);
            }

            // [GLOBAL PALETTE]
            for (int c = 0; c < (useLocal ? 0x80 : 0x100); ++c)
            {
                writer.Write(palette[c].R);
                writer.Write(palette[c].G);
                writer.Write(palette[c].B);
            }
            #endregion

            #region Extension Blocks
            // [EXTENSION BLOCKS]
            #endregion

            #region Image Descriptor Block
            // [IMAGE DESCRIPTOR HEADER]
            writer.Write(',');

            writer.Write((ushort)0);
            writer.Write((ushort)0);
            writer.Write((ushort)width);
            writer.Write((ushort)height);
            if (useLocal)
            {
                writer.Write((byte)((1 << 7) | (0 << 6) | 6)); // 1 == useLocal, 0 == no interlacing, 6 == 7bpp
            }
            else
            {
                writer.Write((byte)((0 << 7) | (0 << 6) | 0)); // 0 == noLocal, 0 == no interlacing, no local palette, so we dont care
            }
            // [LOCAL PALETTE]
            if (useLocal)
            {
                for (int c = 0x80; c < 0x100; ++c)
                {
                    writer.Write(palette[c].R);
                    writer.Write(palette[c].G);
                    writer.Write(palette[c].B);
                }
            }

            // [IMAGE DATA]
            writePictureData(width, height, false, useLocal ? (byte)7 : (byte)8, writer);

            // [BLOCK END MARKER]
            writer.Write(';'); // ';' used for image descriptor, 0 would be used for other blocks
            #endregion

            writer.Close();
        }
Ejemplo n.º 7
0
        public void write(Writer writer)
        {
            List <DataInfo> dataInfo = new List <DataInfo>();

            // Script Code
            dataInfo.Clear();
            for (int dataPos = 0; dataPos < scriptCodeLength;)
            {
                DataInfo info = new DataInfo();
                info.data.Clear();
                info.readInt = scriptCode[dataPos] < 0 || scriptCode[dataPos] >= 0x100;
                if (!info.readInt)
                {
                    for (int i = 0; (scriptCode[dataPos] >= 0 && scriptCode[dataPos] < 0x100) && i < 0x7F; ++i)
                    {
                        info.data.Add(scriptCode[dataPos++]);
                        if (dataPos >= scriptCodeLength)
                        {
                            break;
                        }
                    }
                    dataInfo.Add(info);
                }
                else
                {
                    for (int i = 0; (scriptCode[dataPos] < 0 || scriptCode[dataPos] >= 0x100) && i < 0x7F; ++i)
                    {
                        info.data.Add(scriptCode[dataPos++]);
                        if (dataPos >= scriptCodeLength)
                        {
                            break;
                        }
                    }
                    dataInfo.Add(info);
                }
            }

            int count = dataInfo.Take(dataInfo.Count).Sum(x => x.data.Count);

            writer.Write(count);

            for (int i = 0; i < dataInfo.Count; ++i)
            {
                DataInfo info = dataInfo[i];
                writer.Write((byte)(info.data.Count | ((byte)(info.readInt ? 1 : 0) << 7)));
                for (int d = 0; d < info.data.Count; ++d)
                {
                    if (info.readInt)
                    {
                        writer.Write(info.data[d]);
                    }
                    else
                    {
                        writer.Write((byte)info.data[d]);
                    }
                }
            }

            // Jump Table
            dataInfo.Clear();
            for (int dataPos = 0; dataPos < jumpTableLength;)
            {
                DataInfo info = new DataInfo();

                info.data.Clear();
                info.readInt = jumpTable[dataPos] < 0 || jumpTable[dataPos] >= 0x100;
                if (!info.readInt)
                {
                    for (int i = 0; (jumpTable[dataPos] >= 0 && jumpTable[dataPos] < 0x100) && i < 0x7F;
                         ++i)
                    {
                        info.data.Add(jumpTable[dataPos++]);
                        if (dataPos >= jumpTableLength)
                        {
                            break;
                        }
                    }
                    dataInfo.Add(info);
                }
                else
                {
                    for (int i = 0; (jumpTable[dataPos] < 0 || jumpTable[dataPos] >= 0x100) && i < 0x7F;
                         ++i)
                    {
                        info.data.Add(jumpTable[dataPos++]);
                        if (dataPos >= jumpTableLength)
                        {
                            break;
                        }
                    }
                    dataInfo.Add(info);
                }
            }

            count = dataInfo.Take(dataInfo.Count).Sum(x => x.data.Count);
            writer.Write(count);

            for (int i = 0; i < dataInfo.Count; ++i)
            {
                DataInfo info = dataInfo[i];
                writer.Write((byte)(info.data.Count | ((byte)(info.readInt ? 1 : 0) << 7)));
                for (int d = 0; d < info.data.Count; ++d)
                {
                    if (info.readInt)
                    {
                        writer.Write(info.data[d]);
                    }
                    else
                    {
                        writer.Write((byte)info.data[d]);
                    }
                }
            }

            // Scripts
            writer.Write((ushort)scripts.Count);

            foreach (ScriptInfo script in scripts)
            {
                writer.Write(script.scriptCodePos_main);
                writer.Write(script.scriptCodePos_draw);
                writer.Write(script.scriptCodePos_startup);
            }

            foreach (ScriptInfo script in scripts)
            {
                writer.Write(script.jumpTablePos_main);
                writer.Write(script.jumpTablePos_draw);
                writer.Write(script.jumpTablePos_startup);
            }

            // Functions
            writer.Write((ushort)functionList.Count);

            foreach (FunctionScript func in functionList)
            {
                writer.Write(func.scriptCodePos);
            }

            foreach (FunctionScript func in functionList)
            {
                writer.Write(func.jumpTablePos);
            }

            writer.Close();
        }
Ejemplo n.º 8
0
        internal void Write(Writer writer)
        {
            // Write zone name
            writer.WriteRSDKString(Title);

            // Write the five "display" bytes we kept
            writer.Write(displayBytes);

            // Write width
            writer.Write((byte)(this.width & 0xff));
            writer.Write((byte)(this.width >> 8));

            // Write height
            writer.Write((byte)(this.height & 0xff));
            writer.Write((byte)(this.height >> 8));

            // Write tilemap
            for (int h = 0; h < this.height; h++)
            {
                for (int w = 0; w < this.width; w++)
                {
                    writer.Write((byte)(this.MapLayout[h][w] & 0xff));
                    writer.Write((byte)(this.MapLayout[h][w] >> 8));
                }
            }

            // Write number of objects
            int num_of_obj = objects.Count;

            writer.Write((byte)(num_of_obj & 0xff));
            writer.Write((byte)((num_of_obj >> 8) & 0xff));
            writer.Write((byte)((num_of_obj >> 16) & 0xff));
            writer.Write((byte)((num_of_obj >> 24) & 0xff));

            // Write objects

            for (int n = 0; n < num_of_obj; n++)
            {
                Object obj         = objects[n];
                int    obj_type    = obj.type;
                int    obj_subtype = obj.subtype;
                int    obj_xPos    = obj.xPos;
                int    obj_yPos    = obj.yPos;

                // Most likely the type and subtypes are still one byte long in v2
                // and the two other bytes are for an empty field

                writer.Write((byte)(obj_type & 0xff));
                writer.Write(obj_type >> 8);

                writer.Write((byte)(obj_subtype & 0xff));
                writer.Write(obj_subtype >> 8);

                //writer.Write(0);
                //writer.Write(0);

                writer.Write((byte)(obj_xPos & 0xff));
                writer.Write((byte)((obj_xPos >> 8) & 0xff));
                writer.Write((byte)((obj_xPos >> 16) & 0xff));
                writer.Write((byte)((obj_xPos >> 24) & 0xff));

                writer.Write((byte)(obj_yPos & 0xff));
                writer.Write((byte)((obj_yPos >> 8) & 0xff));
                writer.Write((byte)((obj_yPos >> 16) & 0xff));
                writer.Write((byte)((obj_yPos >> 24) & 0xff));
            }

            writer.Close();
        }